Changeset 32090 in osm for applications/editors/josm/plugins/seachart

Timestamp:

2016-03-03T08:32:31+01:00 (9 years ago)

Author:

malcolmh

Message:

add RADRFLs

Location:

applications/editors/josm/plugins/seachart

Files:

• jrender/src/jrender/Jrender.java (modified) (3 diffs)
• src/render/Renderer.java (modified) (16 diffs)
• src/render/Rules.java (modified) (54 diffs)
• src/render/Signals.java (modified) (10 diffs)
• src/s57/S57map.java (modified) (1 diff)
• src/symbols/Symbols.java (modified) (1 diff)
• src/symbols/Topmarks.java (modified) (1 diff)

applications/editors/josm/plugins/seachart/jrender/src/jrender/Jrender.java

@@ -89 +89 @@
                 context = new Context();
 
+                int border = 256 / (int)Math.pow(2, (12 - zoom));
                 int size = 256;
                 for (int i = 0; i < (12 - zoom); i++) size *= 2;
-                Rectangle rect = new Rectangle(size, size);
+                Rectangle rect = new Rectangle((size + (2 * border)), (size + (2 * border)));
                 img = new BufferedImage(rect.width, rect.height, BufferedImage.TYPE_INT_ARGB);
                 Renderer.reRender(img.createGraphics(), rect, zoom, 1.0, map, context);
@@ -106 +107 @@
                                 svgGenerator.setSVGCanvasSize(rect.getSize());
                                 svgGenerator.setClip(rect.x, rect.y, rect.width, rect.height);
-                                svgGenerator.translate(-256, -256);
+                                svgGenerator.translate(-border, -border);
                                 Renderer.reRender(svgGenerator, rect, z, 1.0, map, context);
                                 svgGenerator.stream(dstdir + "tst_" + z + "-" + xtile + "-" + ytile + ".svg");
@@ -129 +130 @@
                         String dstnam = dstdir + zoom + "/" + xdir + "/" + ynam + ".png";
                         deletes.remove(dstnam);
-                        send.add("put " + dstnam + " cache/tiles-" + zoom + "-" + xdir + "-" + ynam + ".png");
+                        send.add("put " + dstnam + " tiles/" + zoom + "/" + xdir + "/" + ynam + ".png");
                         File ofile = new File(dstdir + "/" + zoom + "/" + xdir + "/");
                         ofile.mkdirs();

applications/editors/josm/plugins/seachart/src/render/Renderer.java

@@ -56 +56 @@
         }
 
-        public static void symbol(Feature feature, Symbol symbol) {
-                Point2D point = context.getPoint(feature.geom.centre);
+        public static void symbol(Symbol symbol) {
+                Point2D point = context.getPoint(Rules.feature.geom.centre);
                 Symbols.drawSymbol(g2, symbol, sScale, point.getX(), point.getY(), null, null);
         }
-        public static void symbol(Feature feature, Symbol symbol, Scheme scheme) {
-                Point2D point = context.getPoint(feature.geom.centre);
+        public static void symbol(Symbol symbol, Scheme scheme) {
+                Point2D point = context.getPoint(Rules.feature.geom.centre);
                 Symbols.drawSymbol(g2, symbol, sScale, point.getX(), point.getY(), scheme, null);
         }
-        public static void symbol(Feature feature, Symbol symbol, Delta delta) {
-                Point2D point = context.getPoint(feature.geom.centre);
+        public static void symbol(Symbol symbol, Delta delta) {
+                Point2D point = context.getPoint(Rules.feature.geom.centre);
                 Symbols.drawSymbol(g2, symbol, sScale, point.getX(), point.getY(), null, delta);
         }
-        public static void symbol(Feature feature, Symbol symbol, Scheme scheme, Delta delta) {
-                Point2D point = context.getPoint(feature.geom.centre);
+        public static void symbol(Symbol symbol, Scheme scheme, Delta delta) {
+                Point2D point = context.getPoint(Rules.feature.geom.centre);
                 Symbols.drawSymbol(g2, symbol, sScale, point.getX(), point.getY(), scheme, delta);
         }
         
-        public static void cluster(Feature feature, ArrayList<Symbol> symbols) {
+        public static void cluster(ArrayList<Symbol> symbols) {
                 Rectangle2D.Double bbox = null;
                 if (symbols.size() > 4) {
@@ -86 +86 @@
                 switch (symbols.size()) {
                 case 1:
-                        symbol(feature, symbols.get(0), new Delta(Handle.CC, new AffineTransform()));
+                        symbol(symbols.get(0), new Delta(Handle.CC, new AffineTransform()));
                         break;
                 case 2:
-                        symbol(feature, symbols.get(0), new Delta(Handle.RC, new AffineTransform()));
-                        symbol(feature, symbols.get(1), new Delta(Handle.LC, new AffineTransform()));
+                        symbol(symbols.get(0), new Delta(Handle.RC, new AffineTransform()));
+                        symbol(symbols.get(1), new Delta(Handle.LC, new AffineTransform()));
                         break;
                 case 3:
-                        symbol(feature, symbols.get(0), new Delta(Handle.BC, new AffineTransform()));
-                        symbol(feature, symbols.get(1), new Delta(Handle.TR, new AffineTransform()));
-                        symbol(feature, symbols.get(2), new Delta(Handle.TL, new AffineTransform()));
+                        symbol(symbols.get(0), new Delta(Handle.BC, new AffineTransform()));
+                        symbol(symbols.get(1), new Delta(Handle.TR, new AffineTransform()));
+                        symbol(symbols.get(2), new Delta(Handle.TL, new AffineTransform()));
                         break;
                 case 4:
-                        symbol(feature, symbols.get(0), new Delta(Handle.BR, new AffineTransform()));
-                        symbol(feature, symbols.get(1), new Delta(Handle.BL, new AffineTransform()));
-                        symbol(feature, symbols.get(2), new Delta(Handle.TR, new AffineTransform()));
-                        symbol(feature, symbols.get(3), new Delta(Handle.TL, new AffineTransform()));
+                        symbol(symbols.get(0), new Delta(Handle.BR, new AffineTransform()));
+                        symbol(symbols.get(1), new Delta(Handle.BL, new AffineTransform()));
+                        symbol(symbols.get(2), new Delta(Handle.TR, new AffineTransform()));
+                        symbol(symbols.get(3), new Delta(Handle.TL, new AffineTransform()));
                         break;
                 case 5:
-                        symbol(feature, symbols.get(0), new Delta(Handle.BR, new AffineTransform()));
-                        symbol(feature, symbols.get(1), new Delta(Handle.BL, new AffineTransform()));
-                        symbol(feature, symbols.get(2), new Delta(Handle.TR, AffineTransform.getTranslateInstance(-bbox.width/2, 0)));
-                        symbol(feature, symbols.get(3), new Delta(Handle.TC, new AffineTransform()));
-                        symbol(feature, symbols.get(4), new Delta(Handle.TL, AffineTransform.getTranslateInstance(bbox.width/2, 0)));
+                        symbol(symbols.get(0), new Delta(Handle.BR, new AffineTransform()));
+                        symbol(symbols.get(1), new Delta(Handle.BL, new AffineTransform()));
+                        symbol(symbols.get(2), new Delta(Handle.TR, AffineTransform.getTranslateInstance(-bbox.width/2, 0)));
+                        symbol(symbols.get(3), new Delta(Handle.TC, new AffineTransform()));
+                        symbol(symbols.get(4), new Delta(Handle.TL, AffineTransform.getTranslateInstance(bbox.width/2, 0)));
                         break;
                 case 6:
-                        symbol(feature, symbols.get(0), new Delta(Handle.BR, AffineTransform.getTranslateInstance(-bbox.width/2, 0)));
-                        symbol(feature, symbols.get(1), new Delta(Handle.BC, new AffineTransform()));
-                        symbol(feature, symbols.get(2), new Delta(Handle.BL, AffineTransform.getTranslateInstance(bbox.width/2, 0)));
-                        symbol(feature, symbols.get(3), new Delta(Handle.TR, AffineTransform.getTranslateInstance(-bbox.width/2, 0)));
-                        symbol(feature, symbols.get(4), new Delta(Handle.TC, new AffineTransform()));
-                        symbol(feature, symbols.get(5), new Delta(Handle.TL, AffineTransform.getTranslateInstance(bbox.width/2, 0)));
+                        symbol(symbols.get(0), new Delta(Handle.BR, AffineTransform.getTranslateInstance(-bbox.width/2, 0)));
+                        symbol(symbols.get(1), new Delta(Handle.BC, new AffineTransform()));
+                        symbol(symbols.get(2), new Delta(Handle.BL, AffineTransform.getTranslateInstance(bbox.width/2, 0)));
+                        symbol(symbols.get(3), new Delta(Handle.TR, AffineTransform.getTranslateInstance(-bbox.width/2, 0)));
+                        symbol(symbols.get(4), new Delta(Handle.TC, new AffineTransform()));
+                        symbol(symbols.get(5), new Delta(Handle.TL, AffineTransform.getTranslateInstance(bbox.width/2, 0)));
                         break;
                 case 7:
-                        symbol(feature, symbols.get(0), new Delta(Handle.BC, AffineTransform.getTranslateInstance(0, -bbox.height/2)));
-                        symbol(feature, symbols.get(1), new Delta(Handle.RC, AffineTransform.getTranslateInstance(-bbox.width/2, 0)));
-                        symbol(feature, symbols.get(2), new Delta(Handle.CC, new AffineTransform()));
-                        symbol(feature, symbols.get(3), new Delta(Handle.LC, AffineTransform.getTranslateInstance(bbox.width/2, 0)));
-                        symbol(feature, symbols.get(4), new Delta(Handle.TR, AffineTransform.getTranslateInstance(-bbox.width/2, bbox.height/2)));
-                        symbol(feature, symbols.get(5), new Delta(Handle.TC, AffineTransform.getTranslateInstance(0, bbox.height/2)));
-                        symbol(feature, symbols.get(6), new Delta(Handle.TL, AffineTransform.getTranslateInstance(bbox.width/2, bbox.height/2)));
+                        symbol(symbols.get(0), new Delta(Handle.BC, AffineTransform.getTranslateInstance(0, -bbox.height/2)));
+                        symbol(symbols.get(1), new Delta(Handle.RC, AffineTransform.getTranslateInstance(-bbox.width/2, 0)));
+                        symbol(symbols.get(2), new Delta(Handle.CC, new AffineTransform()));
+                        symbol(symbols.get(3), new Delta(Handle.LC, AffineTransform.getTranslateInstance(bbox.width/2, 0)));
+                        symbol(symbols.get(4), new Delta(Handle.TR, AffineTransform.getTranslateInstance(-bbox.width/2, bbox.height/2)));
+                        symbol(symbols.get(5), new Delta(Handle.TC, AffineTransform.getTranslateInstance(0, bbox.height/2)));
+                        symbol(symbols.get(6), new Delta(Handle.TL, AffineTransform.getTranslateInstance(bbox.width/2, bbox.height/2)));
                         break;
                 case 8:
-                        symbol(feature, symbols.get(0), new Delta(Handle.BR, AffineTransform.getTranslateInstance(0, -bbox.height/2)));
-                        symbol(feature, symbols.get(1), new Delta(Handle.BL, AffineTransform.getTranslateInstance(0, -bbox.height/2)));
-                        symbol(feature, symbols.get(2), new Delta(Handle.RC, AffineTransform.getTranslateInstance(-bbox.width/2, 0)));
-                        symbol(feature, symbols.get(3), new Delta(Handle.CC, new AffineTransform()));
-                        symbol(feature, symbols.get(4), new Delta(Handle.LC, AffineTransform.getTranslateInstance(bbox.width/2, 0)));
-                        symbol(feature, symbols.get(5), new Delta(Handle.TR, AffineTransform.getTranslateInstance(-bbox.width/2, bbox.height/2)));
-                        symbol(feature, symbols.get(6), new Delta(Handle.TC, AffineTransform.getTranslateInstance(0, bbox.height/2)));
-                        symbol(feature, symbols.get(7), new Delta(Handle.TL, AffineTransform.getTranslateInstance(bbox.width/2, bbox.height/2)));
+                        symbol(symbols.get(0), new Delta(Handle.BR, AffineTransform.getTranslateInstance(0, -bbox.height/2)));
+                        symbol(symbols.get(1), new Delta(Handle.BL, AffineTransform.getTranslateInstance(0, -bbox.height/2)));
+                        symbol(symbols.get(2), new Delta(Handle.RC, AffineTransform.getTranslateInstance(-bbox.width/2, 0)));
+                        symbol(symbols.get(3), new Delta(Handle.CC, new AffineTransform()));
+                        symbol(symbols.get(4), new Delta(Handle.LC, AffineTransform.getTranslateInstance(bbox.width/2, 0)));
+                        symbol(symbols.get(5), new Delta(Handle.TR, AffineTransform.getTranslateInstance(-bbox.width/2, bbox.height/2)));
+                        symbol(symbols.get(6), new Delta(Handle.TC, AffineTransform.getTranslateInstance(0, bbox.height/2)));
+                        symbol(symbols.get(7), new Delta(Handle.TL, AffineTransform.getTranslateInstance(bbox.width/2, bbox.height/2)));
                         break;
                 case 9:
-                        symbol(feature, symbols.get(0), new Delta(Handle.BR, AffineTransform.getTranslateInstance(-bbox.width/2, -bbox.height/2)));
-                        symbol(feature, symbols.get(1), new Delta(Handle.BC, AffineTransform.getTranslateInstance(0, -bbox.height/2)));
-                        symbol(feature, symbols.get(2), new Delta(Handle.BL, AffineTransform.getTranslateInstance(bbox.width/2, -bbox.height/2)));
-                        symbol(feature, symbols.get(3), new Delta(Handle.RC, AffineTransform.getTranslateInstance(-bbox.width/2, 0)));
-                        symbol(feature, symbols.get(4), new Delta(Handle.CC, new AffineTransform()));
-                        symbol(feature, symbols.get(5), new Delta(Handle.LC, AffineTransform.getTranslateInstance(bbox.width/2, 0)));
-                        symbol(feature, symbols.get(6), new Delta(Handle.TR, AffineTransform.getTranslateInstance(-bbox.width/2, bbox.height/2)));
-                        symbol(feature, symbols.get(7), new Delta(Handle.TC, AffineTransform.getTranslateInstance(0, bbox.height/2)));
-                        symbol(feature, symbols.get(8), new Delta(Handle.TL, AffineTransform.getTranslateInstance(bbox.width/2, bbox.height/2)));
+                        symbol(symbols.get(0), new Delta(Handle.BR, AffineTransform.getTranslateInstance(-bbox.width/2, -bbox.height/2)));
+                        symbol(symbols.get(1), new Delta(Handle.BC, AffineTransform.getTranslateInstance(0, -bbox.height/2)));
+                        symbol(symbols.get(2), new Delta(Handle.BL, AffineTransform.getTranslateInstance(bbox.width/2, -bbox.height/2)));
+                        symbol(symbols.get(3), new Delta(Handle.RC, AffineTransform.getTranslateInstance(-bbox.width/2, 0)));
+                        symbol(symbols.get(4), new Delta(Handle.CC, new AffineTransform()));
+                        symbol(symbols.get(5), new Delta(Handle.LC, AffineTransform.getTranslateInstance(bbox.width/2, 0)));
+                        symbol(symbols.get(6), new Delta(Handle.TR, AffineTransform.getTranslateInstance(-bbox.width/2, bbox.height/2)));
+                        symbol(symbols.get(7), new Delta(Handle.TC, AffineTransform.getTranslateInstance(0, bbox.height/2)));
+                        symbol(symbols.get(8), new Delta(Handle.TL, AffineTransform.getTranslateInstance(bbox.width/2, bbox.height/2)));
                         break;
                 }
@@ -169 +169 @@
         }
 
-        public static void lineSymbols(Feature feature, Symbol prisymb, double space, Symbol secsymb, Symbol tersymb, int ratio, Color col) {
-                if ((feature.geom.prim == Pflag.NOSP) || (feature.geom.prim == Pflag.POINT))
+        public static void lineSymbols(Symbol prisymb, double space, Symbol secsymb, Symbol tersymb, int ratio, Color col) {
+                if ((Rules.feature.geom.prim == Pflag.NOSP) || (Rules.feature.geom.prim == Pflag.POINT))
                         return;
                 Rectangle2D.Double prect = symbolSize(prisymb);
@@ -192 +192 @@
                         boolean stflag = false;
                         Symbol symbol = prisymb;
-                        GeomIterator git = map.new GeomIterator(feature.geom);
+                        GeomIterator git = map.new GeomIterator(Rules.feature.geom);
                         while (git.hasComp()) {
                                 git.nextComp();
@@ -253 +253 @@
         }
 
-        public static void lineVector(Feature feature, LineStyle style) {
+        public static void lineVector(LineStyle style) {
                 Path2D.Double p = new Path2D.Double();
                 p.setWindingRule(GeneralPath.WIND_EVEN_ODD);
                 Point2D point;
-                GeomIterator git = map.new GeomIterator(feature.geom);
+                GeomIterator git = map.new GeomIterator(Rules.feature.geom);
                 while (git.hasComp()) {
                         git.nextComp();
@@ -278 +278 @@
                         }
                 }
-                if ((style.fill != null) && (feature.geom.prim == Pflag.AREA)) {
+                if ((style.fill != null) && (Rules.feature.geom.prim == Pflag.AREA)) {
                         g2.setPaint(style.fill);
                         g2.fill(p);
@@ -298 +298 @@
         }
         
-        public static void lineCircle(Feature feature, LineStyle style, double radius, UniHLU units) {
+        public static void lineCircle(LineStyle style, double radius, UniHLU units) {
                 switch (units) {
                 case HLU_FEET:
@@ -318 +318 @@
                         break;
                 }
-                radius *= context.mile(feature);
+                radius *= context.mile(Rules.feature);
                 Symbol circle = new Symbol();
                 if (style.fill != null) {
@@ -327 +327 @@
                 circle.add(new Instr(Form.STRK, new BasicStroke(style.width, BasicStroke.CAP_BUTT, BasicStroke.JOIN_MITER, 1, style.dash, 0)));
                 circle.add(new Instr(Form.ELPS, new Ellipse2D.Double(-radius,-radius,radius*2,radius*2)));
-                Point2D point = context.getPoint(feature.geom.centre);
+                Point2D point = context.getPoint(Rules.feature.geom.centre);
                 Symbols.drawSymbol(g2, circle, 1, point.getX(), point.getY(), null, null);
         }
 
-        public static void fillPattern(Feature feature, BufferedImage image) {
+        public static void fillPattern(BufferedImage image) {
                 Path2D.Double p = new Path2D.Double();
                 p.setWindingRule(GeneralPath.WIND_EVEN_ODD);
                 Point2D point;
-                switch (feature.geom.prim) {
+                switch (Rules.feature.geom.prim) {
                 case POINT:
-                        point = context.getPoint(feature.geom.centre);
+                        point = context.getPoint(Rules.feature.geom.centre);
                         g2.drawImage(image, new AffineTransformOp(AffineTransform.getScaleInstance(sScale, sScale), AffineTransformOp.TYPE_NEAREST_NEIGHBOR),
                                         (int)(point.getX() - (50 * sScale)), (int)(point.getY() - (50 * sScale)));
                         break;
                 case AREA:
-                        GeomIterator git = map.new GeomIterator(feature.geom);
+                        GeomIterator git = map.new GeomIterator(Rules.feature.geom);
                         while (git.hasComp()) {
                                 git.nextComp();
@@ -365 +365 @@
         }
         
-        public static void labelText(Feature feature, String str, Font font, Color tc) {
-                labelText(feature, str, font, tc, LabelStyle.NONE, null, null, null);
-        }
-        public static void labelText(Feature feature, String str, Font font, Color tc, Delta delta) {
-                labelText(feature, str, font, tc, LabelStyle.NONE, null, null, delta);
-        }
-        public static void labelText(Feature feature, String str, Font font, Color tc, LabelStyle style, Color fg) {
-                labelText(feature, str, font, tc, style, fg, null, null);
-        }
-        public static void labelText(Feature feature, String str, Font font, Color tc, LabelStyle style, Color fg, Color bg) {
-                labelText(feature, str, font, tc, style, fg, bg, null);
-        }
-        public static void labelText(Feature feature, String str, Font font, Color tc, LabelStyle style, Color fg, Delta delta) {
-                labelText(feature, str, font, tc, style, fg, null, delta);
-        }
-        public static void labelText(Feature feature, String str, Font font, Color tc, LabelStyle style, Color fg, Color bg, Delta delta) {
+        public static void labelText(String str, Font font, Color tc) {
+                labelText(str, font, tc, LabelStyle.NONE, null, null, null);
+        }
+        public static void labelText(String str, Font font, Color tc, Delta delta) {
+                labelText(str, font, tc, LabelStyle.NONE, null, null, delta);
+        }
+        public static void labelText(String str, Font font, Color tc, LabelStyle style, Color fg) {
+                labelText(str, font, tc, style, fg, null, null);
+        }
+        public static void labelText(String str, Font font, Color tc, LabelStyle style, Color fg, Color bg) {
+                labelText(str, font, tc, style, fg, bg, null);
+        }
+        public static void labelText(String str, Font font, Color tc, LabelStyle style, Color fg, Delta delta) {
+                labelText(str, font, tc, style, fg, null, delta);
+        }
+        public static void labelText(String str, Font font, Color tc, LabelStyle style, Color fg, Color bg, Delta delta) {
                 if (delta == null) delta = new Delta(Handle.CC);
                 if (bg == null) bg = new Color(0x00000000, true);
@@ -475 +475 @@
                 }
                 label.add(new Instr(Form.TEXT, new Caption(str, font, tc, new Delta(Handle.TL, AffineTransform.getTranslateInstance(tx, ty)))));
-                Point2D point = context.getPoint(feature.geom.centre);
+                Point2D point = context.getPoint(Rules.feature.geom.centre);
                 Symbols.drawSymbol(g2, label, sScale, point.getX(), point.getY(), null, delta);
         }
 
-        public static void lineText(Feature feature, String str, Font font, Color colour, double offset, double dy) {
+        public static void lineText(String str, Font font, Color colour, double offset, double dy) {
                 if (!str.isEmpty()) {
                         g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
@@ -493 +493 @@
                         double angle = 0;
                         int index = 0;
-                        double gwidth = offset * (feature.geom.length * context.mile(feature) - gv.getLogicalBounds().getWidth()) + gv.getGlyphMetrics(0).getAdvance();
-                        GeomIterator git = map.new GeomIterator(feature.geom);
+                        double gwidth = offset * (Rules.feature.geom.length * context.mile(Rules.feature) - gv.getLogicalBounds().getWidth()) + gv.getGlyphMetrics(0).getAdvance();
+                        GeomIterator git = map.new GeomIterator(Rules.feature.geom);
                         while (git.hasComp()) {
                                 git.nextComp();
@@ -548 +548 @@
         }
         
-        public static void lightSector(Feature feature, Color col1, Color col2, double radius, double s1, double s2, Double dir, String str) {
+        public static void lightSector(Color col1, Color col2, double radius, double s1, double s2, Double dir, String str) {
                 if ((zoom >= 16) && (radius > 0.2)) {
                         radius /= (Math.pow(2, zoom-15));
@@ -555 +555 @@
                 g2.setStroke(new BasicStroke((float) (3.0 * sScale), BasicStroke.CAP_BUTT, BasicStroke.JOIN_ROUND, 1, new float[] {20 * (float)sScale, 20 * (float)sScale}, 0));
                 g2.setPaint(Color.black);
-                Point2D.Double centre = (Point2D.Double) context.getPoint(feature.geom.centre);
-                double radial = radius * context.mile(feature);
+                Point2D.Double centre = (Point2D.Double) context.getPoint(Rules.feature.geom.centre);
+                double radial = radius * context.mile(Rules.feature);
                 if (dir != null) {
                         g2.draw(new Line2D.Double(centre.x, centre.y, centre.x - radial * Math.sin(Math.toRadians(dir)), centre.y + radial * Math.cos(Math.toRadians(dir))));
@@ -585 +585 @@
                         if (gv.getLogicalBounds().getWidth() < awidth) {
                                 at.rotate(Math.toRadians(mid + (hand ? 0 : 180)));
-                                Renderer.labelText(feature, str, font, Color.black, new Delta(Handle.CC, at));
+                                Renderer.labelText(str, font, Color.black, new Delta(Handle.CC, at));
                         } else if (gv.getLogicalBounds().getHeight() < awidth) {
                                 hand = (mid < 180);
                                 at.rotate(Math.toRadians(mid + (hand ? -90 : 90)));
-                                Renderer.labelText(feature, str, font, Color.black, hand ? new Delta(Handle.RC, at) : new Delta(Handle.LC, at));
+                                Renderer.labelText(str, font, Color.black, hand ? new Delta(Handle.RC, at) : new Delta(Handle.LC, at));
                         }
                         if (dir != null) {
@@ -599 +599 @@
                                 at = AffineTransform.getTranslateInstance(-radial * Math.sin(phi) / sScale, radial * Math.cos(phi) / sScale);
                                 at.rotate(Math.toRadians(dir + (hand ? 90 : -90)));
-                                Renderer.labelText(feature, str, font, Color.black, hand ? new Delta(Handle.BR, at) : new Delta(Handle.BL, at));
+                                Renderer.labelText(str, font, Color.black, hand ? new Delta(Handle.BR, at) : new Delta(Handle.BL, at));
                         }
                 }

applications/editors/josm/plugins/seachart/src/render/Rules.java

@@ -13 +13 @@
 import java.awt.Font;
 import java.awt.geom.AffineTransform;
+import java.text.DecimalFormat;
 import java.util.ArrayList;
 import java.util.EnumMap;
@@ -29 +30 @@
 public class Rules {
         
+        static final DecimalFormat df = new DecimalFormat("#.#");
+
         static final EnumMap<ColCOL, Color> bodyColours = new EnumMap<ColCOL, Color>(ColCOL.class);
         static {
@@ -71 +74 @@
         }
 
-        public static void addName(Feature feature, int z, Font font) {
-                addName(feature, z, font, Color.black, new Delta(Handle.CC, new AffineTransform()));
-        }
-        public static void addName(Feature feature, int z, Font font, Color colour) {
-                addName(feature, z, font, colour, new Delta(Handle.CC, new AffineTransform()));
-        }
-        public static void addName(Feature feature, int z, Font font, Delta delta) {
-                addName(feature, z, font, Color.black, delta);
-        }
-        public static void addName(Feature feature, int z, Font font, Color colour, Delta delta) {
+        public static void addName(int z, Font font) {
+                addName(z, font, Color.black, new Delta(Handle.CC, new AffineTransform()));
+        }
+        public static void addName(int z, Font font, Color colour) {
+                addName(z, font, colour, new Delta(Handle.CC, new AffineTransform()));
+        }
+        public static void addName(int z, Font font, Delta delta) {
+                addName(z, font, Color.black, delta);
+        }
+        public static void addName(int z, Font font, Color colour, Delta delta) {
                 if (Renderer.zoom >= z) {
                         String name = getName();
                         if (name != null) {
-                                Renderer.labelText(feature, name, font,  colour, delta);
-                        }
-                }
-        }
-
-        static AttMap getAtts(Feature feature, Obj obj, int idx) {
+                                Renderer.labelText(name, font,  colour, delta);
+                        }
+                }
+        }
+
+        static AttMap getAtts(Obj obj, int idx) {
                 HashMap<Integer, AttMap> objs = feature.objs.get(obj);
                 if (objs == null)
@@ -97 +100 @@
         }
 
-        public static Object getAttVal(Feature feature, Obj obj, int idx, Att att) {
+        public static Object getAttVal(Obj obj, Att att) {
                 AttMap atts;
                 HashMap<Integer, AttMap> objs;
                 AttVal<?> item;
                 if ((objs = feature.objs.get(obj)) != null)
-                        atts = objs.get(idx);
+                        atts = objs.get(0);
                 else
                         return null;
@@ -111 +114 @@
         }
         
-        public static String getAttStr(Feature feature, Obj obj, int idx, Att att) {
-                String str = (String)getAttVal(feature, obj, idx, att);
+        public static String getAttStr(Obj obj, Att att) {
+                String str = (String)getAttVal(obj, att);
                 if (str != null) {
                         return str;
@@ -118 +121 @@
                 return ""; 
         }
-        
+
         @SuppressWarnings("unchecked")
-        public static Enum<?> getAttEnum(Feature feature, Obj obj, int idx, Att att) {
-                ArrayList<?> list = (ArrayList<?>)getAttVal(feature, obj, idx, att);
+        public static Enum<?> getAttEnum(Obj obj, Att att) {
+                ArrayList<?> list = (ArrayList<?>)getAttVal(obj, att);
                 if (list != null) {
                         return ((ArrayList<Enum<?>>)list).get(0);
@@ -129 +132 @@
         
         @SuppressWarnings("unchecked")
-        public static ArrayList<?> getAttList(Feature feature, Obj obj, int idx, Att att) {
-                ArrayList<Enum<?>> list = (ArrayList<Enum<?>>)getAttVal(feature, obj, idx, att);
+        public static ArrayList<?> getAttList(Obj obj, Att att) {
+                ArrayList<Enum<?>> list = (ArrayList<Enum<?>>)getAttVal(obj, att);
                 if (list != null) {
                         return list;
@@ -140 +143 @@
         
         @SuppressWarnings("unchecked")
-        static Scheme getScheme(Feature feature, Obj obj) {
+        static Scheme getScheme(Obj obj) {
                 ArrayList<Color> colours = new ArrayList<Color>();
-                for (ColCOL col : (ArrayList<ColCOL>) getAttList(feature, obj, 0, Att.COLOUR)) {
+                for (ColCOL col : (ArrayList<ColCOL>) getAttList(obj, Att.COLOUR)) {
                         colours.add(bodyColours.get(col));
                 }
                 ArrayList<Patt> patterns = new ArrayList<Patt>();
-                for (ColPAT pat : (ArrayList<ColPAT>) getAttList(feature, obj, 0, Att.COLPAT)) {
+                for (ColPAT pat : (ArrayList<ColPAT>) getAttList(obj, Att.COLPAT)) {
                         patterns.add(pattMap.get(pat));
                 }
                 return new Scheme(patterns, colours);
         }
-        
-        static boolean testAttribute(Feature feature, Obj obj, int idx, Att att, Object val) {
+
+        static boolean hasAttribute(Obj obj, int idx, Att att) {
                 AttMap atts;
-                if ((atts = getAtts(feature, obj, idx)) != null) {
+                if ((atts = getAtts(obj, idx)) != null) {
+                        AttVal<?> item = atts.get(att);
+                        return item != null;
+                }
+                return false;
+        }
+        
+        static boolean testAttribute(Obj obj, Att att, Object val) {
+                AttMap atts;
+                if ((atts = getAtts(obj, 0)) != null) {
                         AttVal<?> item = atts.get(att);
                         if (item != null) {
@@ -161 +173 @@
                                 case A:
                                         return ((String)item.val).equals(val);
+                                case E:
                                 case L:
                                         return ((ArrayList<?>)item.val).contains(val);
-                                case E:
                                 case F:
                                 case I:
-                                        return item.val.equals(val);
+                                        return item.val == val;
                                 }
                         }
@@ -173 +185 @@
         }
         
-        static Feature feature;
+        public static Feature feature;
         static ArrayList<Feature> objects;
         
@@ -248 +260 @@
                         if (testObject(Obj.CGUSTA)) for (Feature f : objects) if (testFeature(f)) stations();
                         if (testObject(Obj.RDOSTA)) for (Feature f : objects) if (testFeature(f)) stations();
+                        if (testObject(Obj.RADRFL)) for (Feature f : objects) if (testFeature(f)) stations();
                         if (testObject(Obj.RADSTA)) for (Feature f : objects) if (testFeature(f)) stations();
                         if (testObject(Obj.RTPBCN)) for (Feature f : objects) if (testFeature(f)) stations();
@@ -275 +288 @@
                 switch (feature.type) {
                 case BUAARE:
-                        Renderer.lineVector(feature, new LineStyle(new Color(0x20000000, true)));
+                        Renderer.lineVector(new LineStyle(new Color(0x20000000, true)));
                         break;
                 case COALNE:
                         if (Renderer.zoom >= 12)
-                                Renderer.lineVector(feature, new LineStyle(Color.black, 10));
+                                Renderer.lineVector(new LineStyle(Color.black, 10));
                         break;
                 case DEPARE:
                         Double depmax = 0.0;
-                        if (((depmax = (Double) getAttVal(feature, Obj.DEPARE, 0, Att.DRVAL2)) != null) && (depmax <= 0.0)) {
-                                Renderer.lineVector(feature, new LineStyle(Symbols.Gdries));
+                        if (((depmax = (Double) getAttVal(Obj.DEPARE, Att.DRVAL2)) != null) && (depmax <= 0.0)) {
+                                Renderer.lineVector(new LineStyle(Symbols.Gdries));
                         }
                         break;
                 case LAKARE:
                         if ((Renderer.zoom >= 12) || (feature.geom.area > 10.0))
-                                Renderer.lineVector(feature, new LineStyle(Symbols.Bwater));
+                                Renderer.lineVector(new LineStyle(Symbols.Bwater));
                         break;
                 case DRGARE:
                         if (Renderer.zoom < 16)
-                                Renderer.lineVector(feature, new LineStyle(Color.black, 8, new float[] { 25, 25 }, new Color(0x40ffffff, true)));
+                                Renderer.lineVector(new LineStyle(Color.black, 8, new float[] { 25, 25 }, new Color(0x40ffffff, true)));
                         else
-                                Renderer.lineVector(feature, new LineStyle(Color.black, 8, new float[] { 25, 25 }));
-                        addName(feature, 12, new Font("Arial", Font.PLAIN, 100), new Delta(Handle.CC, new AffineTransform()));
+                                Renderer.lineVector(new LineStyle(Color.black, 8, new float[] { 25, 25 }));
+                        addName(12, new Font("Arial", Font.PLAIN, 100), new Delta(Handle.CC, new AffineTransform()));
                         break;
                 case FAIRWY:
                         if (feature.geom.area > 2.0) {
                                 if (Renderer.zoom < 16)
-                                        Renderer.lineVector(feature, new LineStyle(Symbols.Mline, 8, new float[] { 50, 50 }, new Color(0x40ffffff, true)));
+                                        Renderer.lineVector(new LineStyle(Symbols.Mline, 8, new float[] { 50, 50 }, new Color(0x40ffffff, true)));
                                 else
-                                        Renderer.lineVector(feature, new LineStyle(Symbols.Mline, 8, new float[] { 50, 50 }));
+                                        Renderer.lineVector(new LineStyle(Symbols.Mline, 8, new float[] { 50, 50 }));
                         } else {
                                 if (Renderer.zoom >= 14)
-                                        Renderer.lineVector(feature, new LineStyle(new Color(0x40ffffff, true)));
+                                        Renderer.lineVector(new LineStyle(new Color(0x40ffffff, true)));
                         }
                         break;
@@ -313 +326 @@
                 case HRBBSN:
                         if (Renderer.zoom >= 12) {
-                                Renderer.lineVector(feature, new LineStyle(Color.black, 10, Symbols.Bwater));
+                                Renderer.lineVector(new LineStyle(Color.black, 10, Symbols.Bwater));
                         } else {
-                                Renderer.lineVector(feature, new LineStyle(Symbols.Bwater));
+                                Renderer.lineVector(new LineStyle(Symbols.Bwater));
                         }
                         break;
@@ -321 +334 @@
                         if (feature.objs.get(Obj.HRBBSN) != null) {
                                 if (Renderer.zoom >= 12) {
-                                        Renderer.lineVector(feature, new LineStyle(Color.black, 10, Symbols.Bwater));
+                                        Renderer.lineVector(new LineStyle(Color.black, 10, Symbols.Bwater));
                                 } else {
-                                        Renderer.lineVector(feature, new LineStyle(Symbols.Bwater));
+                                        Renderer.lineVector(new LineStyle(Symbols.Bwater));
                                 }
                         }
                         break;
                 case LNDARE:
-                        Renderer.lineVector(feature, new LineStyle(Symbols.Yland));
+                        Renderer.lineVector(new LineStyle(Symbols.Yland));
                         break;
                 case MARCUL:
                         if (Renderer.zoom >= 12) {
                                 if (Renderer.zoom >= 14) {
-                                        Renderer.symbol(feature, Areas.MarineFarm);
+                                        Renderer.symbol(Areas.MarineFarm);
                                 }
                                 if ((feature.geom.area > 0.2) || ((feature.geom.area > 0.05) && (Renderer.zoom >= 14)) || ((feature.geom.area > 0.005) && (Renderer.zoom >= 16))) {
-                                        Renderer.lineVector(feature, new LineStyle(Color.black, 4, new float[] { 10, 10 }));
+                                        Renderer.lineVector(new LineStyle(Color.black, 4, new float[] { 10, 10 }));
                                 }
                         }
                         break;
                 case OSPARE:
-                        if (testAttribute(feature, feature.type, 0, Att.CATPRA, CatPRA.PRA_WFRM)) {
-                                Renderer.symbol(feature, Areas.WindFarm);
-                                Renderer.lineVector(feature, new LineStyle(Color.black, 20, new float[] { 40, 40 }));
-                                addName(feature, 15, new Font("Arial", Font.BOLD, 80), new Delta(Handle.TC, AffineTransform.getTranslateInstance(0, 10)));
+                        if (testAttribute(feature.type, Att.CATPRA, CatPRA.PRA_WFRM)) {
+                                Renderer.symbol(Areas.WindFarm);
+                                Renderer.lineVector(new LineStyle(Color.black, 20, new float[] { 40, 40 }));
+                                addName(15, new Font("Arial", Font.BOLD, 80), new Delta(Handle.TC, AffineTransform.getTranslateInstance(0, 10)));
                         }
                         break;
@@ -350 +363 @@
                 case MIPARE:
                         if (Renderer.zoom >= 12) {
-                                Renderer.lineSymbols(feature, Areas.Restricted, 1.0, null, null, 0, Symbols.Mline);
-                                if (testAttribute(feature, feature.type, 0, Att.CATREA, CatREA.REA_NWAK)) {
-                                        Renderer.symbol(feature, Areas.NoWake);
+                                Renderer.lineSymbols(Areas.Restricted, 1.0, null, null, 0, Symbols.Mline);
+                                if (testAttribute(feature.type, Att.CATREA, CatREA.REA_NWAK)) {
+                                        Renderer.symbol(Areas.NoWake);
                                 }
                         }
@@ -358 +371 @@
                 case PRCARE:
                         if (Renderer.zoom >= 12) {
-                                Renderer.lineVector(feature, new LineStyle(Symbols.Mline, 10, new float[] { 40, 40 }));
+                                Renderer.lineVector(new LineStyle(Symbols.Mline, 10, new float[] { 40, 40 }));
                         }
                         break;
                 case SEAARE:
-                        switch ((CatSEA) getAttEnum(feature, feature.type, 0, Att.CATSEA)) {
+                        switch ((CatSEA) getAttEnum(feature.type, Att.CATSEA)) {
                         case SEA_RECH:
                                 if ((Renderer.zoom >= 10) && (name != null))
                                         if (feature.geom.prim == Pflag.LINE) {
-                                                Renderer.lineText(feature, name, new Font("Arial", Font.PLAIN, 150), Color.black, 0.5, -40);
+                                                Renderer.lineText(name, new Font("Arial", Font.PLAIN, 150), Color.black, 0.5, -40);
                                         } else {
-                                                Renderer.labelText(feature, name, new Font("Arial", Font.PLAIN, 150), Color.black, new Delta(Handle.BC, AffineTransform.getTranslateInstance(0, -40)));
+                                                Renderer.labelText(name, new Font("Arial", Font.PLAIN, 150), Color.black, new Delta(Handle.BC, AffineTransform.getTranslateInstance(0, -40)));
                                         }
                                 break;
@@ -374 +387 @@
                                 if ((Renderer.zoom >= 12) && (name != null))
                                         if (feature.geom.prim == Pflag.LINE) {
-                                                Renderer.lineText(feature, name, new Font("Arial", Font.PLAIN, 150), Color.black, 0.5, -40);
+                                                Renderer.lineText(name, new Font("Arial", Font.PLAIN, 150), Color.black, 0.5, -40);
                                         } else {
-                                                Renderer.labelText(feature, name, new Font("Arial", Font.PLAIN, 150), Color.black, new Delta(Handle.BC, AffineTransform.getTranslateInstance(0, -40)));
+                                                Renderer.labelText(name, new Font("Arial", Font.PLAIN, 150), Color.black, new Delta(Handle.BC, AffineTransform.getTranslateInstance(0, -40)));
                                         }
                                 break;
@@ -382 +395 @@
                                 if (Renderer.zoom >= 14) {
                                         if (feature.geom.prim == Pflag.AREA) {
-                                                Renderer.lineVector(feature, new LineStyle(new Color(0xc480ff), 4, new float[] { 25, 25 }));
+                                                Renderer.lineVector(new LineStyle(new Color(0xc480ff), 4, new float[] { 25, 25 }));
                                                 if (name != null) {
-                                                        Renderer.labelText(feature, name, new Font("Arial", Font.ITALIC, 75), Color.black, new Delta(Handle.BC, AffineTransform.getTranslateInstance(0, -40)));
-                                                        Renderer.labelText(feature, "(Shoal)", new Font("Arial", Font.PLAIN, 60), Color.black, new Delta(Handle.BC));
+                                                        Renderer.labelText(name, new Font("Arial", Font.ITALIC, 75), Color.black, new Delta(Handle.BC, AffineTransform.getTranslateInstance(0, -40)));
+                                                        Renderer.labelText("(Shoal)", new Font("Arial", Font.PLAIN, 60), Color.black, new Delta(Handle.BC));
                                                 }
                                         } else if (feature.geom.prim == Pflag.LINE) {
                                                 if (name != null) {
-                                                        Renderer.lineText(feature, name, new Font("Arial", Font.ITALIC, 75), Color.black, 0.5, -40);
-                                                        Renderer.lineText(feature, "(Shoal)", new Font("Arial", Font.PLAIN, 60), Color.black, 0.5, 0);
+                                                        Renderer.lineText(name, new Font("Arial", Font.ITALIC, 75), Color.black, 0.5, -40);
+                                                        Renderer.lineText("(Shoal)", new Font("Arial", Font.PLAIN, 60), Color.black, 0.5, 0);
                                                 }
                                         } else {
                                                 if (name != null) {
-                                                        Renderer.labelText(feature, name, new Font("Arial", Font.ITALIC, 75), Color.black, new Delta(Handle.BC, AffineTransform.getTranslateInstance(0, -40)));
-                                                        Renderer.labelText(feature, "(Shoal)", new Font("Arial", Font.PLAIN, 60), Color.black, new Delta(Handle.BC));
+                                                        Renderer.labelText(name, new Font("Arial", Font.ITALIC, 75), Color.black, new Delta(Handle.BC, AffineTransform.getTranslateInstance(0, -40)));
+                                                        Renderer.labelText("(Shoal)", new Font("Arial", Font.PLAIN, 60), Color.black, new Delta(Handle.BC));
                                                 }
                                         }
@@ -402 +415 @@
                         case SEA_GAT:
                         case SEA_NRRW:
-                                addName(feature, 12, new Font("Arial", Font.PLAIN, 100));
+                                addName(12, new Font("Arial", Font.PLAIN, 100));
                                 break;
                         default:
@@ -409 +422 @@
                         break;
                 case SNDWAV:
-                        if (Renderer.zoom >= 12) Renderer.fillPattern(feature, Areas.Sandwaves);
+                        if (Renderer.zoom >= 12) Renderer.fillPattern(Areas.Sandwaves);
                         break;
                 case SPLARE:
                         if (Renderer.zoom >= 12) {
-                                Renderer.symbol(feature, Areas.Plane, new Scheme(Symbols.Msymb));
-                                Renderer.lineSymbols(feature, Areas.Restricted, 0.5, Areas.LinePlane, null, 10, Symbols.Mline);
-                        }
-                        addName(feature, 15, new Font("Arial", Font.BOLD, 80), new Delta(Handle.BC, AffineTransform.getTranslateInstance(0, -90)));
+                                Renderer.symbol(Areas.Plane, new Scheme(Symbols.Msymb));
+                                Renderer.lineSymbols(Areas.Restricted, 0.5, Areas.LinePlane, null, 10, Symbols.Mline);
+                        }
+                        addName(15, new Font("Arial", Font.BOLD, 80), new Delta(Handle.BC, AffineTransform.getTranslateInstance(0, -90)));
                         break;
                 default:
@@ -426 +439 @@
         private static void beacons() {
                 if ((Renderer.zoom >= 14) || ((Renderer.zoom >= 12) && ((feature.type == Obj.BCNLAT) || (feature.type == Obj.BCNCAR)))) {
-                        BcnSHP shape = (BcnSHP)getAttEnum(feature, feature.type, 0, Att.BCNSHP);
+                        BcnSHP shape = (BcnSHP)getAttEnum(feature.type, Att.BCNSHP);
                         if (shape == BcnSHP.BCN_UNKN)
                                 shape = BcnSHP.BCN_PILE;
                         if ((shape == BcnSHP.BCN_WTHY) && (feature.type == Obj.BCNLAT)) {
-                                switch ((CatLAM) getAttEnum(feature, feature.type, 0, Att.CATLAM)) {
+                                switch ((CatLAM) getAttEnum(feature.type, Att.CATLAM)) {
                                 case LAM_PORT:
-                                        Renderer.symbol(feature, Beacons.WithyPort);
+                                        Renderer.symbol(Beacons.WithyPort);
                                         break;
                                 case LAM_STBD:
-                                        Renderer.symbol(feature, Beacons.WithyStarboard);
+                                        Renderer.symbol(Beacons.WithyStarboard);
                                         break;
                                 default:
-                                        Renderer.symbol(feature, Beacons.Stake, getScheme(feature, feature.type));
+                                        Renderer.symbol(Beacons.Stake, getScheme(feature.type));
                                 }
                         } else if ((shape == BcnSHP.BCN_PRCH) && (feature.type == Obj.BCNLAT) && !(feature.objs.containsKey(Obj.TOPMAR))) {
-                                switch ((CatLAM) getAttEnum(feature, feature.type, 0, Att.CATLAM)) {
+                                switch ((CatLAM) getAttEnum(feature.type, Att.CATLAM)) {
                                 case LAM_PORT:
-                                        Renderer.symbol(feature, Beacons.PerchPort);
+                                        Renderer.symbol(Beacons.PerchPort);
                                         break;
                                 case LAM_STBD:
-                                        Renderer.symbol(feature, Beacons.PerchStarboard);
+                                        Renderer.symbol(Beacons.PerchStarboard);
                                         break;
                                 default:
-                                        Renderer.symbol(feature, Beacons.Stake, getScheme(feature, feature.type));
+                                        Renderer.symbol(Beacons.Stake, getScheme(feature.type));
                                 }
                         } else {
-                                Renderer.symbol(feature, Beacons.Shapes.get(shape), getScheme(feature, feature.type));
+                                Renderer.symbol(Beacons.Shapes.get(shape), getScheme(feature.type));
                                 if (feature.objs.containsKey(Obj.TOPMAR)) {
                                         AttMap topmap = feature.objs.get(Obj.TOPMAR).get(0);
                                         if (topmap.containsKey(Att.TOPSHP)) {
-                                                Renderer.symbol(feature, Topmarks.Shapes.get(((ArrayList<TopSHP>)(topmap.get(Att.TOPSHP).val)).get(0)), getScheme(feature, Obj.TOPMAR), Topmarks.BeaconDelta);
+                                                Renderer.symbol(Topmarks.Shapes.get(((ArrayList<TopSHP>)(topmap.get(Att.TOPSHP).val)).get(0)), getScheme(Obj.TOPMAR), Topmarks.BeaconDelta);
                                         }
                                 } else if (feature.objs.containsKey(Obj.DAYMAR)) {
                                         AttMap topmap = feature.objs.get(Obj.DAYMAR).get(0);
                                         if (topmap.containsKey(Att.TOPSHP)) {
-                                                Renderer.symbol(feature, Topmarks.Shapes.get(((ArrayList<TopSHP>)(topmap.get(Att.TOPSHP).val)).get(0)), getScheme(feature, Obj.DAYMAR), Topmarks.BeaconDelta);
-                                        }
-                                }
-                        }
-                        addName(feature, 15, new Font("Arial", Font.BOLD, 40), new Delta(Handle.BL, AffineTransform.getTranslateInstance(60, -50)));
-                        Signals.addSignals(feature);
+                                                Renderer.symbol(Topmarks.Shapes.get(((ArrayList<TopSHP>)(topmap.get(Att.TOPSHP).val)).get(0)), getScheme(Obj.DAYMAR), Topmarks.BeaconDelta);
+                                        }
+                                }
+                        }
+                        addName(15, new Font("Arial", Font.BOLD, 40), new Delta(Handle.BL, AffineTransform.getTranslateInstance(60, -50)));
+                        Signals.addSignals();
                 }
         }
@@ -473 +486 @@
         private static void buoys() {
                 if ((Renderer.zoom >= 14) || ((Renderer.zoom >= 12) && ((feature.type == Obj.BOYLAT) || (feature.type == Obj.BOYCAR)))) {
-                        BoySHP shape = (BoySHP) getAttEnum(feature, feature.type, 0, Att.BOYSHP);
+                        BoySHP shape = (BoySHP) getAttEnum(feature.type, Att.BOYSHP);
                         if (shape == BoySHP.BOY_UNKN) shape = BoySHP.BOY_PILR;
-                        Renderer.symbol(feature, Buoys.Shapes.get(shape), getScheme(feature, feature.type));
+                        Renderer.symbol(Buoys.Shapes.get(shape), getScheme(feature.type));
                         if (feature.objs.containsKey(Obj.TOPMAR)) {
                                 AttMap topmap = feature.objs.get(Obj.TOPMAR).get(0);
                                 if (topmap.containsKey(Att.TOPSHP)) {
-                                        Renderer.symbol(feature, Topmarks.Shapes.get(((ArrayList<TopSHP>)(topmap.get(Att.TOPSHP).val)).get(0)), getScheme(feature, Obj.TOPMAR), Topmarks.BuoyDeltas.get(shape));
+                                        Renderer.symbol(Topmarks.Shapes.get(((ArrayList<TopSHP>)(topmap.get(Att.TOPSHP).val)).get(0)), getScheme(Obj.TOPMAR), Topmarks.BuoyDeltas.get(shape));
                                 }
                         } else if (feature.objs.containsKey(Obj.DAYMAR)) {
                                 AttMap topmap = feature.objs.get(Obj.DAYMAR).get(0);
                                 if (topmap.containsKey(Att.TOPSHP)) {
-                                        Renderer.symbol(feature, Topmarks.Shapes.get(((ArrayList<TopSHP>)(topmap.get(Att.TOPSHP).val)).get(0)), getScheme(feature, Obj.DAYMAR), Topmarks.BuoyDeltas.get(shape));
-                                }
-                        }
-                        addName(feature, 15, new Font("Arial", Font.BOLD, 40), new Delta(Handle.BL, AffineTransform.getTranslateInstance(60, -50)));
-                        Signals.addSignals(feature);
+                                        Renderer.symbol(Topmarks.Shapes.get(((ArrayList<TopSHP>)(topmap.get(Att.TOPSHP).val)).get(0)), getScheme(Obj.DAYMAR), Topmarks.BuoyDeltas.get(shape));
+                                }
+                        }
+                        addName(15, new Font("Arial", Font.BOLD, 40), new Delta(Handle.BL, AffineTransform.getTranslateInstance(60, -50)));
+                        Signals.addSignals();
                 }
         }
@@ -520 +533 @@
                                 }
                                 if (hstr.isEmpty() && !vstr.isEmpty()) {
-                                        Renderer.labelText(feature, vstr, new Font("Arial", Font.PLAIN, 30), Color.black, LabelStyle.VCLR, Color.black, Color.white, new Delta(Handle.CC));
+                                        Renderer.labelText(vstr, new Font("Arial", Font.PLAIN, 30), Color.black, LabelStyle.VCLR, Color.black, Color.white, new Delta(Handle.CC));
                                 } else if (!hstr.isEmpty() && !vstr.isEmpty()) {
-                                        Renderer.labelText(feature, vstr, new Font("Arial", Font.PLAIN, 30), Color.black, LabelStyle.VCLR, Color.black, Color.white, new Delta(Handle.BC));
-                                        Renderer.labelText(feature, hstr, new Font("Arial", Font.PLAIN, 30), Color.black, LabelStyle.HCLR, Color.black, Color.white, new Delta(Handle.TC));
+                                        Renderer.labelText(vstr, new Font("Arial", Font.PLAIN, 30), Color.black, LabelStyle.VCLR, Color.black, Color.white, new Delta(Handle.BC));
+                                        Renderer.labelText(hstr, new Font("Arial", Font.PLAIN, 30), Color.black, LabelStyle.HCLR, Color.black, Color.white, new Delta(Handle.TC));
                                 } else if (!hstr.isEmpty() && vstr.isEmpty()) {
-                                        Renderer.labelText(feature, hstr, new Font("Arial", Font.PLAIN, 30), Color.black, LabelStyle.HCLR, Color.black, Color.white, new Delta(Handle.CC));
+                                        Renderer.labelText(hstr, new Font("Arial", Font.PLAIN, 30), Color.black, LabelStyle.HCLR, Color.black, Color.white, new Delta(Handle.CC));
                                 }
                         }
@@ -534 +547 @@
                 if ((Renderer.zoom >= 16) && (feature.geom.length < 2)) {
                         if (feature.type == Obj.CBLSUB) {
-                                Renderer.lineSymbols(feature, Areas.Cable, 0.0, null, null, 0, Symbols.Mline);
+                                Renderer.lineSymbols(Areas.Cable, 0.0, null, null, 0, Symbols.Mline);
                         } else if (feature.type == Obj.CBLOHD) {
                                 AttMap atts = feature.objs.get(Obj.CBLOHD).get(0);
                                 if ((atts != null) && (atts.containsKey(Att.CATCBL)) && (atts.get(Att.CATCBL).val == CatCBL.CBL_POWR)) {
-                                        Renderer.lineSymbols(feature, Areas.CableDash, 0, Areas.CableDot, Areas.CableFlash, 2, Color.black);
+                                        Renderer.lineSymbols(Areas.CableDash, 0, Areas.CableDot, Areas.CableFlash, 2, Color.black);
                                 } else {
-                                        Renderer.lineSymbols(feature, Areas.CableDash, 0, Areas.CableDot, null, 2, Color.black);
+                                        Renderer.lineSymbols(Areas.CableDash, 0, Areas.CableDot, null, 2, Color.black);
                                 }
                                 if (atts != null) {
                                         if (atts.containsKey(Att.VERCLR)) {
-                                                Renderer.labelText(feature, String.valueOf((Double) atts.get(Att.VERCLR).val), new Font("Arial", Font.PLAIN, 50), Color.black, LabelStyle.VCLR, Color.black, new Delta(Handle.TC, AffineTransform.getTranslateInstance(0,25)));
+                                                Renderer.labelText(String.valueOf((Double) atts.get(Att.VERCLR).val), new Font("Arial", Font.PLAIN, 50), Color.black, LabelStyle.VCLR, Color.black, new Delta(Handle.TC, AffineTransform.getTranslateInstance(0,25)));
                                         } else if (atts.containsKey(Att.VERCSA)) {
-                                                Renderer.labelText(feature, String.valueOf((Double) atts.get(Att.VERCSA).val), new Font("Arial", Font.PLAIN, 50), Color.black, LabelStyle.PCLR, Color.black, new Delta(Handle.TC, AffineTransform.getTranslateInstance(0,25)));
+                                                Renderer.labelText(String.valueOf((Double) atts.get(Att.VERCSA).val), new Font("Arial", Font.PLAIN, 50), Color.black, LabelStyle.PCLR, Color.black, new Delta(Handle.TC, AffineTransform.getTranslateInstance(0,25)));
                                         }
                                 }
@@ -556 +569 @@
                 if (Renderer.zoom >= 14) {
                         Symbol symb = Harbours.CallPoint2;
-                        TrfTRF trf = (TrfTRF) getAttEnum(feature, feature.type, 0, Att.TRAFIC);
+                        TrfTRF trf = (TrfTRF) getAttEnum(feature.type, Att.TRAFIC);
                         if (trf != TrfTRF.TRF_TWOW) {
                                 symb = Harbours.CallPoint1;
                         }
                         Double orient = 0.0;
-                        if ((orient = (Double) getAttVal(feature, feature.type, 0, Att.ORIENT)) == null) {
+                        if ((orient = (Double) getAttVal(feature.type, Att.ORIENT)) == null) {
                                 orient = 0.0;
                         }
-                        Renderer.symbol(feature, symb, new Delta(Handle.CC, AffineTransform.getRotateInstance(Math.toRadians(orient))));
+                        Renderer.symbol(symb, new Delta(Handle.CC, AffineTransform.getRotateInstance(Math.toRadians(orient))));
                         String chn;
-                        if (!(chn = getAttStr(feature, feature.type, 0, Att.COMCHA)).isEmpty()) {
-                                Renderer.labelText(feature, ("Ch." + chn), new Font("Arial", Font.PLAIN, 50), Color.black, new Delta(Handle.TC, AffineTransform.getTranslateInstance(0,50)));
+                        if (!(chn = getAttStr(feature.type, Att.COMCHA)).isEmpty()) {
+                                Renderer.labelText(("Ch." + chn), new Font("Arial", Font.PLAIN, 50), Color.black, new Delta(Handle.TC, AffineTransform.getTranslateInstance(0,50)));
                         }
                 }
@@ -574 +587 @@
         private static void distances() {
                 if (Renderer.zoom >= 14) {
-                        if (!testAttribute(feature, Obj.DISMAR, 0, Att.CATDIS, CatDIS.DIS_NONI)) {
-                                Renderer.symbol(feature, Harbours.DistanceI);
+                        if (!testAttribute(Obj.DISMAR, Att.CATDIS, CatDIS.DIS_NONI)) {
+                                Renderer.symbol(Harbours.DistanceI);
                         } else {
-                                Renderer.symbol(feature, Harbours.DistanceU);
+                                Renderer.symbol(Harbours.DistanceU);
                         }
                         if (Renderer.zoom >= 15) {
-                                AttMap atts = getAtts(feature, Obj.DISMAR, 0);
+                                AttMap atts = getAtts(Obj.DISMAR, 0);
                                 if ((atts != null) && (atts.containsKey(Att.WTWDIS))) {
                                         Double dist = (Double) atts.get(Att.WTWDIS).val;
@@ -609 +622 @@
                                         }
                                         str += String.format("%1.0f", dist);
-                                        Renderer.labelText(feature, str, new Font("Arial", Font.PLAIN, 40), Color.black, new Delta(Handle.CC, AffineTransform.getTranslateInstance(0, 45)));
+                                        Renderer.labelText(str, new Font("Arial", Font.PLAIN, 40), Color.black, new Delta(Handle.CC, AffineTransform.getTranslateInstance(0, 45)));
                                 }
                         }
@@ -616 +629 @@
         
         private static void floats() {
-                switch (feature.type) {
-                case LITVES:
-                        Renderer.symbol(feature, Buoys.Super, getScheme(feature, feature.type));
-                        break;
-                case LITFLT:
-                        Renderer.symbol(feature, Buoys.Float, getScheme(feature, feature.type));
-                        break;
-                case BOYINB:
-                        Renderer.symbol(feature, Buoys.Super, getScheme(feature, feature.type));
-                        break;
-                default:
-                        break;
-                }
-                if (feature.objs.get(Obj.TOPMAR) != null)
-                        Renderer.symbol(feature, Topmarks.Shapes.get(feature.objs.get(Obj.TOPMAR).get(0).get(Att.TOPSHP).val), getScheme(feature, Obj.TOPMAR), Topmarks.FloatDelta);
-                addName(feature, 15, new Font("Arial", Font.BOLD, 40), new Delta(Handle.BL, AffineTransform.getTranslateInstance(20, -50)));
-                Signals.addSignals(feature);
+                if (Renderer.zoom >= 12) {
+                        switch (feature.type) {
+                        case LITVES:
+                                Renderer.symbol(Buoys.Super, getScheme(feature.type));
+                                break;
+                        case LITFLT:
+                                Renderer.symbol(Buoys.Float, getScheme(feature.type));
+                                break;
+                        case BOYINB:
+                                Renderer.symbol(Buoys.Super, getScheme(feature.type));
+                                break;
+                        default:
+                                break;
+                        }
+                        if (feature.objs.get(Obj.TOPMAR) != null)
+                                Renderer.symbol(Topmarks.Shapes.get(feature.objs.get(Obj.TOPMAR).get(0).get(Att.TOPSHP).val), getScheme(Obj.TOPMAR), Topmarks.FloatDelta);
+                        addName(15, new Font("Arial", Font.BOLD, 40), new Delta(Handle.BL, AffineTransform.getTranslateInstance(20, -50)));
+                        Signals.addSignals();
+                }
         }
         
         private static void gauges() {
                 if (Renderer.zoom >= 14) {
-                        Renderer.symbol(feature, Harbours.TideGauge);
-                        addName(feature, 15, new Font("Arial", Font.BOLD, 40), new Delta(Handle.BL, AffineTransform.getTranslateInstance(20, -50)));
-                        Signals.addSignals(feature);
+                        Renderer.symbol(Harbours.TideGauge);
+                        addName(15, new Font("Arial", Font.BOLD, 40), new Delta(Handle.BL, AffineTransform.getTranslateInstance(20, -50)));
+                        Signals.addSignals();
                 }
         }
@@ -649 +664 @@
                 case ACHBRT:
                         if (Renderer.zoom >= 14) {
-                                Renderer.symbol(feature, Harbours.Anchorage, new Scheme(Symbols.Mline));
+                                Renderer.symbol(Harbours.Anchorage, new Scheme(Symbols.Mline));
                                 if (Renderer.zoom >= 15) {
-                                        Renderer.labelText(feature, name == null ? "" : name, new Font("Arial", Font.PLAIN, 30), Symbols.Msymb, LabelStyle.RRCT, Symbols.Mline, Color.white, new Delta(Handle.BC));
-                                }
-                        }
-                        if (getAttVal(feature, Obj.ACHBRT, 0, Att.RADIUS) != null) {
+                                        Renderer.labelText(name == null ? "" : name, new Font("Arial", Font.PLAIN, 30), Symbols.Msymb, LabelStyle.RRCT, Symbols.Mline, Color.white, new Delta(Handle.BC));
+                                }
+                        }
+                        if (getAttVal(Obj.ACHBRT, Att.RADIUS) != null) {
                                 double radius;
-                                if ((radius = (Double) getAttVal(feature, Obj.ACHBRT, 0, Att.RADIUS)) != 0) {
-                                        UniHLU units = (UniHLU) getAttEnum(feature, Obj.ACHBRT, 0, Att.HUNITS);
+                                if ((radius = (Double) getAttVal(Obj.ACHBRT, Att.RADIUS)) != 0) {
+                                        UniHLU units = (UniHLU) getAttEnum(Obj.ACHBRT, Att.HUNITS);
                                         if (units == UniHLU.HLU_UNKN) {
                                                 units = UniHLU.HLU_METR;
                                         }
-                                        Renderer.lineCircle(feature, new LineStyle(Symbols.Mline, 4, new float[] { 10, 10 }, null), radius, units);
+                                        Renderer.lineCircle(new LineStyle(Symbols.Mline, 4, new float[] { 10, 10 }, null), radius, units);
                                 }
                         }
@@ -668 +683 @@
                         if (Renderer.zoom >= 12) {
                                 if (feature.geom.prim != Pflag.AREA) {
-                                        Renderer.symbol(feature, Harbours.Anchorage, new Scheme(Color.black));
+                                        Renderer.symbol(Harbours.Anchorage, new Scheme(Color.black));
                                 } else {
-                                        Renderer.symbol(feature, Harbours.Anchorage, new Scheme(Symbols.Mline));
-                                        Renderer.lineSymbols(feature, Areas.Restricted, 1.0, Areas.LineAnchor, null, 10, Symbols.Mline);
-                                }
-                                addName(feature, 15, new Font("Arial", Font.BOLD, 60), Symbols.Mline, new Delta(Handle.LC, AffineTransform.getTranslateInstance(70, 0)));
-                                ArrayList<StsSTS> sts = (ArrayList<StsSTS>)getAttList(feature, Obj.ACHARE, 0, Att.STATUS);
+                                        Renderer.symbol(Harbours.Anchorage, new Scheme(Symbols.Mline));
+                                        Renderer.lineSymbols(Areas.Restricted, 1.0, Areas.LineAnchor, null, 10, Symbols.Mline);
+                                }
+                                addName(15, new Font("Arial", Font.BOLD, 60), Symbols.Mline, new Delta(Handle.LC, AffineTransform.getTranslateInstance(70, 0)));
+                                ArrayList<StsSTS> sts = (ArrayList<StsSTS>) getAttList(Obj.ACHARE, Att.STATUS);
                                 if ((Renderer.zoom >= 15) && (sts.contains(StsSTS.STS_RESV))) {
-                                        Renderer.labelText(feature, "Reserved", new Font("Arial", Font.PLAIN, 50), Symbols.Mline, new Delta(Handle.TC, AffineTransform.getTranslateInstance(0, 60)));
-                                }
-                        }
-                        ArrayList<CatACH> cats = (ArrayList<CatACH>) getAttList(feature, Obj.ACHARE, 0, Att.CATACH);
-                        int dy = (cats.size() - 1) * -30;
-                        for (CatACH cat : cats) {
-                                switch (cat) {
-                                case ACH_DEEP:
-                                        Renderer.labelText(feature, "DW", new Font("Arial", Font.BOLD, 50), Symbols.Msymb, new Delta(Handle.RC, AffineTransform.getTranslateInstance(-60, dy)));
-                                        dy += 60;
-                                        break;
-                                case ACH_TANK:
-                                        Renderer.labelText(feature, "Tanker", new Font("Arial", Font.BOLD, 50), Symbols.Msymb, new Delta(Handle.RC, AffineTransform.getTranslateInstance(-60, dy)));
-                                        dy += 60;
-                                        break;
-                                case ACH_H24P:
-                                        Renderer.labelText(feature, "24h", new Font("Arial", Font.BOLD, 50), Symbols.Msymb, new Delta(Handle.RC, AffineTransform.getTranslateInstance(-60, dy)));
-                                        dy += 60;
-                                        break;
-                                case ACH_EXPL:
-                                        Renderer.symbol(feature, Harbours.Explosives, new Scheme(Symbols.Msymb), new Delta(Handle.RC, AffineTransform.getTranslateInstance(-60, dy)));
-                                        dy += 60;
-                                        break;
-                                case ACH_QUAR:
-                                        Renderer.symbol(feature, Harbours.Hospital, new Scheme(Symbols.Msymb), new Delta(Handle.RC, AffineTransform.getTranslateInstance(-60, dy)));
-                                        dy += 60;
-                                        break;
-                                case ACH_SEAP:
-                                        Renderer.symbol(feature, Areas.Seaplane, new Scheme(Symbols.Msymb), new Delta(Handle.RC, AffineTransform.getTranslateInstance(-60, dy)));
-                                        dy += 60;
-                                        break;
-                                default:
+                                        Renderer.labelText("Reserved", new Font("Arial", Font.PLAIN, 50), Symbols.Mline, new Delta(Handle.TC, AffineTransform.getTranslateInstance(0, 60)));
+                                }
+                                ArrayList<CatACH> cats = (ArrayList<CatACH>) getAttList(Obj.ACHARE, Att.CATACH);
+                                int dy = (cats.size() - 1) * -30;
+                                for (CatACH cat : cats) {
+                                        switch (cat) {
+                                        case ACH_DEEP:
+                                                Renderer.labelText("DW", new Font("Arial", Font.BOLD, 50), Symbols.Msymb, new Delta(Handle.RC, AffineTransform.getTranslateInstance(-60, dy)));
+                                                dy += 60;
+                                                break;
+                                        case ACH_TANK:
+                                                Renderer.labelText("Tanker", new Font("Arial", Font.BOLD, 50), Symbols.Msymb, new Delta(Handle.RC, AffineTransform.getTranslateInstance(-60, dy)));
+                                                dy += 60;
+                                                break;
+                                        case ACH_H24P:
+                                                Renderer.labelText("24h", new Font("Arial", Font.BOLD, 50), Symbols.Msymb, new Delta(Handle.RC, AffineTransform.getTranslateInstance(-60, dy)));
+                                                dy += 60;
+                                                break;
+                                        case ACH_EXPL:
+                                                Renderer.symbol(Harbours.Explosives, new Scheme(Symbols.Msymb), new Delta(Handle.RC, AffineTransform.getTranslateInstance(-60, dy)));
+                                                dy += 60;
+                                                break;
+                                        case ACH_QUAR:
+                                                Renderer.symbol(Harbours.Hospital, new Scheme(Symbols.Msymb), new Delta(Handle.RC, AffineTransform.getTranslateInstance(-60, dy)));
+                                                dy += 60;
+                                                break;
+                                        case ACH_SEAP:
+                                                Renderer.symbol(Areas.Seaplane, new Scheme(Symbols.Msymb), new Delta(Handle.RC, AffineTransform.getTranslateInstance(-60, dy)));
+                                                dy += 60;
+                                                break;
+                                        default:
+                                        }
                                 }
                         }
@@ -713 +728 @@
                 case BERTHS:
                         if (Renderer.zoom >= 14) {
-                                Renderer.lineVector(feature, new LineStyle(Symbols.Mline, 6, new float[] { 20, 20 }));
-                                Renderer.labelText(feature, name == null ? " " : name, new Font("Arial", Font.PLAIN, 40), Symbols.Msymb, LabelStyle.RRCT, Symbols.Mline, Color.white);
+                                Renderer.lineVector(new LineStyle(Symbols.Mline, 6, new float[] { 20, 20 }));
+                                Renderer.labelText(name == null ? " " : name, new Font("Arial", Font.PLAIN, 40), Symbols.Msymb, LabelStyle.RRCT, Symbols.Mline, Color.white);
                         }
                         break;
@@ -720 +735 @@
                         if (Renderer.zoom >= 16) {
                                 ArrayList<Symbol> symbols = new ArrayList<Symbol>();
-                                ArrayList<FncFNC> fncs = (ArrayList<FncFNC>) getAttList(feature, Obj.BUISGL, 0, Att.FUNCTN);
+                                ArrayList<FncFNC> fncs = (ArrayList<FncFNC>) getAttList(Obj.BUISGL, Att.FUNCTN);
                                 for (FncFNC fnc : fncs) {
                                         symbols.add(Landmarks.Funcs.get(fnc));
                                 }
                                 if (feature.objs.containsKey(Obj.SMCFAC)) {
-                                        ArrayList<CatSCF> scfs = (ArrayList<CatSCF>) getAttList(feature, Obj.SMCFAC, 0, Att.CATSCF);
+                                        ArrayList<CatSCF> scfs = (ArrayList<CatSCF>) getAttList(Obj.SMCFAC, Att.CATSCF);
                                         for (CatSCF scf : scfs) {
                                                 symbols.add(Facilities.Cats.get(scf));
                                         }
                                 }
-                                Renderer.cluster(feature, symbols);
+                                Renderer.cluster(symbols);
                         }
                         break;
                 case HRBFAC:
                         if (Renderer.zoom >= 12) {
-                                ArrayList<CatHAF> cathaf = (ArrayList<CatHAF>) getAttList(feature, Obj.HRBFAC, 0, Att.CATHAF);
+                                ArrayList<CatHAF> cathaf = (ArrayList<CatHAF>) getAttList(Obj.HRBFAC, Att.CATHAF);
                                 if (cathaf.size() == 1) {
                                         switch (cathaf.get(0)) {
                                         case HAF_MRNA:
-                                                Renderer.symbol(feature, Harbours.Marina);
+                                                Renderer.symbol(Harbours.Marina);
                                                 break;
                                         case HAF_MANF:
-                                                Renderer.symbol(feature, Harbours.MarinaNF);
+                                                Renderer.symbol(Harbours.MarinaNF);
                                                 break;
                                         case HAF_FISH:
-                                                Renderer.symbol(feature, Harbours.Fishing);
+                                                Renderer.symbol(Harbours.Fishing);
                                                 break;
                                         default:
-                                                Renderer.symbol(feature, Harbours.Harbour);
+                                                Renderer.symbol(Harbours.Harbour);
                                                 break;
                                         }
                                 } else {
-                                        Renderer.symbol(feature, Harbours.Harbour);
+                                        Renderer.symbol(Harbours.Harbour);
                                 }
                         }
@@ -765 +780 @@
                 switch (feature.type) {
                 case ROADWY:
-                        ArrayList<CatROD> cat = (ArrayList<CatROD>) (getAttList(feature, Obj.ROADWY, 0, Att.CATROD));
+                        ArrayList<CatROD> cat = (ArrayList<CatROD>) (getAttList(Obj.ROADWY, Att.CATROD));
                         if (cat.size() > 0) {
                                 switch (cat.get(0)) {
                                 case ROD_MWAY:
-                                        Renderer.lineVector(feature, new LineStyle(Color.black, 20));
+                                        Renderer.lineVector(new LineStyle(Color.black, 20));
                                         break;
                                 case ROD_MAJR:
-                                        Renderer.lineVector(feature, new LineStyle(Color.black, 15));
+                                        Renderer.lineVector(new LineStyle(Color.black, 15));
                                         break;
                                 case ROD_MINR:
-                                        Renderer.lineVector(feature, new LineStyle(Color.black, 10));
+                                        Renderer.lineVector(new LineStyle(Color.black, 10));
                                         break;
                                 default:
-                                        Renderer.lineVector(feature, new LineStyle(Color.black, 5));
+                                        Renderer.lineVector(new LineStyle(Color.black, 5));
                                 }
                         } else {
-                                Renderer.lineVector(feature, new LineStyle(Color.black, 5));
+                                Renderer.lineVector(new LineStyle(Color.black, 5));
                         }
                         break;
                 case RAILWY:
-                        Renderer.lineVector(feature, new LineStyle(Color.gray, 10));
-                        Renderer.lineVector(feature, new LineStyle(Color.black, 10, new float[] { 30, 30 }));
+                        Renderer.lineVector(new LineStyle(Color.gray, 10));
+                        Renderer.lineVector(new LineStyle(Color.black, 10, new float[] { 30, 30 }));
                         break;
                 default:
@@ -794 +809 @@
         @SuppressWarnings("unchecked")
         private static void landmarks() {
-                ArrayList<CatLMK> cats = (ArrayList<CatLMK>) getAttList(feature, feature.type, 0, Att.CATLMK);
-                Symbol catSym = Landmarks.Shapes.get(cats.get(0));
-                ArrayList<FncFNC> fncs = (ArrayList<FncFNC>) getAttList(feature, feature.type, 0, Att.FUNCTN);
-                Symbol fncSym = Landmarks.Funcs.get(fncs.get(0));
-                if ((fncs.get(0) == FncFNC.FNC_CHCH) && (cats.get(0) == CatLMK.LMK_TOWR))
-                        catSym = Landmarks.ChurchTower;
-                if ((cats.get(0) == CatLMK.LMK_UNKN) && (fncs.get(0) == FncFNC.FNC_UNKN) && (feature.objs.get(Obj.LIGHTS) != null))
-                        catSym = Beacons.LightMajor;
-                if (cats.get(0) == CatLMK.LMK_RADR)
-                        fncSym = Landmarks.RadioTV;
-                Renderer.symbol(feature, catSym);
-                Renderer.symbol(feature, fncSym);
-                addName(feature, 15, new Font("Arial", Font.BOLD, 40), new Delta(Handle.BL, AffineTransform.getTranslateInstance(60, -50)));
-                Signals.addSignals(feature);
-        }
-        
+                if (Renderer.zoom >= 12) {
+                        ArrayList<CatLMK> cats = (ArrayList<CatLMK>) getAttList(feature.type, Att.CATLMK);
+                        Symbol catSym = Landmarks.Shapes.get(cats.get(0));
+                        ArrayList<FncFNC> fncs = (ArrayList<FncFNC>) getAttList(feature.type, Att.FUNCTN);
+                        Symbol fncSym = Landmarks.Funcs.get(fncs.get(0));
+                        if ((fncs.get(0) == FncFNC.FNC_CHCH) && (cats.get(0) == CatLMK.LMK_TOWR))
+                                catSym = Landmarks.ChurchTower;
+                        if ((cats.get(0) == CatLMK.LMK_UNKN) && (fncs.get(0) == FncFNC.FNC_UNKN) && (feature.objs.get(Obj.LIGHTS) != null))
+                                catSym = Beacons.LightMajor;
+                        if (cats.get(0) == CatLMK.LMK_RADR)
+                                fncSym = Landmarks.RadioTV;
+                        Renderer.symbol(catSym);
+                        Renderer.symbol(fncSym);
+                        if (Renderer.zoom >= 15)
+                                addName(15, new Font("Arial", Font.BOLD, 40), new Delta(Handle.BL, AffineTransform.getTranslateInstance(60, -50)));
+                        Signals.addSignals();
+                }
+        }
+        
+        @SuppressWarnings("unchecked")
         private static void lights() {
                 switch (feature.type) {
                 case LITMAJ:
-                        Renderer.symbol(feature, Beacons.LightMajor);
+                        Renderer.symbol(Beacons.LightMajor);
                         break;
                 case LITMIN:
                 case LIGHTS:
-                        Renderer.symbol(feature, Beacons.LightMinor);
+                        Renderer.symbol(Beacons.LightMinor);
                         break;
                 case PILPNT:
                         if (feature.objs.containsKey(Obj.LIGHTS))
-                                Renderer.symbol(feature, Beacons.LightMinor);
+                                Renderer.symbol(Beacons.LightMinor);
                         else
-                                Renderer.symbol(feature, Harbours.Post);
+                                Renderer.symbol(Harbours.Post);
                         break;
                 default:
@@ -829 +848 @@
                 }
                 if (feature.objs.containsKey(Obj.TOPMAR)) {
-                        Symbol topmark = Topmarks.Shapes.get(feature.objs.get(Obj.TOPMAR).get(0).get(Att.TOPSHP).val);
-                        if (topmark != null)
-                                Renderer.symbol(feature, Topmarks.Shapes.get(feature.objs.get(Obj.TOPMAR).get(0).get(Att.TOPSHP).val), getScheme(feature, Obj.TOPMAR), Topmarks.LightDelta);
+                        AttMap topmap = feature.objs.get(Obj.TOPMAR).get(0);
+                        if (topmap.containsKey(Att.TOPSHP)) {
+                                Renderer.symbol(Topmarks.Shapes.get(((ArrayList<TopSHP>)(topmap.get(Att.TOPSHP).val)).get(0)), getScheme(Obj.TOPMAR), Topmarks.LightDelta);
+                        }
                 } else  if (feature.objs.containsKey(Obj.DAYMAR)) {
-                        Symbol topmark = Topmarks.Shapes.get(feature.objs.get(Obj.DAYMAR).get(0).get(Att.TOPSHP).val);
-                        if (topmark != null)
-                                Renderer.symbol(feature, Topmarks.Shapes.get(feature.objs.get(Obj.DAYMAR).get(0).get(Att.TOPSHP).val), getScheme(feature, Obj.DAYMAR), Topmarks.LightDelta);
-                }
-                Signals.addSignals(feature);
+                        AttMap topmap = feature.objs.get(Obj.DAYMAR).get(0);
+                        if (topmap.containsKey(Att.TOPSHP)) {
+                                Renderer.symbol(Topmarks.Shapes.get(((ArrayList<TopSHP>)(topmap.get(Att.TOPSHP).val)).get(0)), getScheme(Obj.DAYMAR), Topmarks.LightDelta);
+                        }
+                }
+                Signals.addSignals();
         }
 
@@ -844 +865 @@
                 if (Renderer.zoom >= 16) {
                         ArrayList<Symbol> symbols = new ArrayList<Symbol>();
-                        ArrayList<CatSCF> scfs = (ArrayList<CatSCF>) getAttList(feature, Obj.SMCFAC, 0, Att.CATSCF);
+                        ArrayList<CatSCF> scfs = (ArrayList<CatSCF>) getAttList(Obj.SMCFAC, Att.CATSCF);
                         for (CatSCF scf : scfs) {
                                 symbols.add(Facilities.Cats.get(scf));
                         }
-                        Renderer.cluster(feature, symbols);
+                        Renderer.cluster(symbols);
                 }
         }
         
         private static void moorings() {
-                switch ((CatMOR) getAttEnum(feature, feature.type, 0, Att.CATMOR)) {
-                case MOR_DLPN:
-                        Renderer.symbol(feature, Harbours.Dolphin);
-                        break;
-                case MOR_DDPN:
-                        Renderer.symbol(feature, Harbours.DeviationDolphin);
-                        break;
-                case MOR_BLRD:
-                case MOR_POST:
-                        Renderer.symbol(feature, Harbours.Bollard);
-                        break;
-                case MOR_BUOY:
-                        BoySHP shape = (BoySHP) getAttEnum(feature, feature.type, 0, Att.BOYSHP);
-                        if (shape == BoySHP.BOY_UNKN) {
-                                shape = BoySHP.BOY_SPHR;
-                        }
-                        Renderer.symbol(feature, Buoys.Shapes.get(shape), getScheme(feature, feature.type));
-                        Renderer.symbol(feature, Topmarks.TopMooring, Topmarks.BuoyDeltas.get(shape));
-                        break;
-                default:
-                        break;
-                }
-                Signals.addSignals(feature);
+                if (Renderer.zoom >= 14) {
+                        switch ((CatMOR) getAttEnum(feature.type, Att.CATMOR)) {
+                        case MOR_DLPN:
+                                Renderer.symbol(Harbours.Dolphin);
+                                break;
+                        case MOR_DDPN:
+                                Renderer.symbol(Harbours.DeviationDolphin);
+                                break;
+                        case MOR_BLRD:
+                        case MOR_POST:
+                                Renderer.symbol(Harbours.Bollard);
+                                break;
+                        case MOR_BUOY:
+                                BoySHP shape = (BoySHP) getAttEnum(feature.type, Att.BOYSHP);
+                                if (shape == BoySHP.BOY_UNKN) {
+                                        shape = BoySHP.BOY_SPHR;
+                                }
+                                Renderer.symbol(Buoys.Shapes.get(shape), getScheme(feature.type));
+                                Renderer.symbol(Topmarks.TopMooring, Topmarks.BuoyDeltas.get(shape));
+                                break;
+                        default:
+                                break;
+                        }
+                        Signals.addSignals();
+                }
         }
 
@@ -902 +925 @@
                         int n = objs.size();
                         if (n > 5) {
-                                Renderer.symbol(feature, Notices.Notice, new Delta(Handle.CC, AffineTransform.getTranslateInstance(dx, dy)));
+                                Renderer.symbol(Notices.Notice, new Delta(Handle.CC, AffineTransform.getTranslateInstance(dx, dy)));
                         } else {
                                 int i = 0;
@@ -937 +960 @@
                                                 break;
                                         }
-                                        if (h != null) Renderer.symbol(feature, sym, new Delta(h, AffineTransform.getTranslateInstance(dx, dy)));
+                                        if (h != null) Renderer.symbol(sym, new Delta(h, AffineTransform.getTranslateInstance(dx, dy)));
                                         i++;
                                 }
@@ -946 +969 @@
         private static void obstructions() {
                 if ((Renderer.zoom >= 12) && (feature.type == Obj.OBSTRN)) {
-                        switch ((CatOBS) getAttEnum(feature, feature.type, 0, Att.CATOBS)) {
+                        switch ((CatOBS) getAttEnum(feature.type, Att.CATOBS)) {
                         case OBS_BOOM:
-                                Renderer.lineVector(feature, new LineStyle(Color.black, 5, new float[] { 20, 20 }, null));
+                                Renderer.lineVector(new LineStyle(Color.black, 5, new float[] { 20, 20 }, null));
                                 if (Renderer.zoom >= 15) {
-                                        Renderer.lineText(feature, "Boom", new Font("Arial", Font.PLAIN, 80), Color.black, 0.5, -20);
+                                        Renderer.lineText("Boom", new Font("Arial", Font.PLAIN, 80), Color.black, 0.5, -20);
                                 }
                         default:
@@ -957 +980 @@
                 }
                 if ((Renderer.zoom >= 14) && (feature.type == Obj.UWTROC)) {
-                        switch ((WatLEV) getAttEnum(feature, feature.type, 0, Att.WATLEV)) {
+                        switch ((WatLEV) getAttEnum(feature.type, Att.WATLEV)) {
                         case LEV_CVRS:
-                                Renderer.symbol(feature, Areas.RockC);
+                                Renderer.symbol(Areas.RockC);
                                 break;
                         case LEV_AWSH:
-                                Renderer.symbol(feature, Areas.RockA);
+                                Renderer.symbol(Areas.RockA);
                                 break;
                         default:
-                                Renderer.symbol(feature, Areas.Rock);
+                                Renderer.symbol(Areas.Rock);
                         }
                 } else {
-                        Renderer.symbol(feature, Areas.Rock);
+                        Renderer.symbol(Areas.Rock);
                 }
         }
@@ -975 +998 @@
                 if ((Renderer.zoom >= 16) && (feature.geom.length < 2)) {
                         if (feature.type == Obj.PIPSOL) {
-                                Renderer.lineSymbols(feature, Areas.Pipeline, 1.0, null, null, 0, Symbols.Mline);
+                                Renderer.lineSymbols(Areas.Pipeline, 1.0, null, null, 0, Symbols.Mline);
                         } else if (feature.type == Obj.PIPOHD) {
-                                Renderer.lineVector(feature, new LineStyle(Color.black, 8));
+                                Renderer.lineVector(new LineStyle(Color.black, 8));
                                 AttMap atts = feature.atts;
                                 double verclr = 0;
@@ -987 +1010 @@
                                         }
                                         if (verclr > 0) {
-                                                Renderer.labelText(feature, String.valueOf(verclr), new Font("Arial", Font.PLAIN, 50), Color.black, LabelStyle.VCLR, Color.black, new Delta(Handle.TC, AffineTransform.getTranslateInstance(0,25)));
+                                                Renderer.labelText(String.valueOf(verclr), new Font("Arial", Font.PLAIN, 50), Color.black, LabelStyle.VCLR, Color.black, new Delta(Handle.TC, AffineTransform.getTranslateInstance(0,25)));
                                         }
                                 }
@@ -996 +1019 @@
         @SuppressWarnings("unchecked")
         private static void platforms() {
-                ArrayList<CatOFP> cats = (ArrayList<CatOFP>) getAttList(feature, Obj.OFSPLF, 0, Att.CATOFP);
+                ArrayList<CatOFP> cats = (ArrayList<CatOFP>) getAttList(Obj.OFSPLF, Att.CATOFP);
                 if ((CatOFP) cats.get(0) == CatOFP.OFP_FPSO)
-                        Renderer.symbol(feature, Buoys.Storage);
+                        Renderer.symbol(Buoys.Storage);
                 else
-                        Renderer.symbol(feature, Landmarks.Platform);
-                addName(feature, 15, new Font("Arial", Font.BOLD, 40), new Delta(Handle.BL, AffineTransform.getTranslateInstance(20, -50)));
-                Signals.addSignals(feature);
+                        Renderer.symbol(Landmarks.Platform);
+                addName(15, new Font("Arial", Font.BOLD, 40), new Delta(Handle.BL, AffineTransform.getTranslateInstance(20, -50)));
+                Signals.addSignals();
         }
 
@@ -1008 +1031 @@
                 if (Renderer.zoom >= 14) {
                         if (feature.type == Obj.CRANES) {
-                                if ((CatCRN) getAttEnum(feature, feature.type, 0, Att.CATCRN) == CatCRN.CRN_CONT)
-                                        Renderer.symbol(feature, Harbours.ContainerCrane);
+                                if ((CatCRN) getAttEnum(feature.type, Att.CATCRN) == CatCRN.CRN_CONT)
+                                        Renderer.symbol(Harbours.ContainerCrane);
                                 else
-                                        Renderer.symbol(feature, Harbours.PortCrane);
+                                        Renderer.symbol(Harbours.PortCrane);
                         } else if (feature.type == Obj.HULKES) {
-                                Renderer.lineVector(feature, new LineStyle(Color.black, 4, null, new Color(0xffe000)));
-                                addName(feature, 15, new Font("Arial", Font.BOLD, 40));
+                                Renderer.lineVector(new LineStyle(Color.black, 4, null, new Color(0xffe000)));
+                                addName(15, new Font("Arial", Font.BOLD, 40));
                         }
                 }
@@ -1025 +1048 @@
                 case TSSRON:
                         if (Renderer.zoom <= 15)
-                                Renderer.lineVector(feature, new LineStyle(Symbols.Mline));
+                                Renderer.lineVector(new LineStyle(Symbols.Mtss));
                         else
-                                Renderer.lineVector(feature, new LineStyle(Symbols.Mline, 20, null, null));
-                        addName(feature, 10, new Font("Arial", Font.BOLD, 150), Symbols.Mline);
+                                Renderer.lineVector(new LineStyle(Symbols.Mtss, 20, null, null));
+                        addName(10, new Font("Arial", Font.BOLD, 150), Symbols.Mline);
                         break;
                 case TSELNE:
-                        Renderer.lineVector(feature, new LineStyle(Symbols.Mline, 20, null, null));
+                        Renderer.lineVector(new LineStyle(Symbols.Mtss, 20, null, null));
                         break;
                 case TSSLPT:
-                        Renderer.lineSymbols(feature, Areas.LaneArrow, 0.5, null, null, 0, Symbols.Mline);
+                        Renderer.lineSymbols(Areas.LaneArrow, 0.5, null, null, 0, Symbols.Mtss);
                         break;
                 case TSSBND:
-                        Renderer.lineVector(feature, new LineStyle(Symbols.Mline, 20, new float[] { 40, 40 }, null));
+                        Renderer.lineVector(new LineStyle(Symbols.Mtss, 20, new float[] { 40, 40 }, null));
                         break;
                 case ISTZNE:
-                        Renderer.lineSymbols(feature, Areas.Restricted, 1.0, null, null, 0, Symbols.Mline);
+                        Renderer.lineSymbols(Areas.Restricted, 1.0, null, null, 0, Symbols.Mtss);
                         break;
                 default:
@@ -1049 +1072 @@
         @SuppressWarnings("unchecked")
         private static void shoreline() {
-                CatSLC cat = (CatSLC) getAttEnum(feature, feature.type, 0, Att.CATSLC);
+                CatSLC cat = (CatSLC) getAttEnum(feature.type, Att.CATSLC);
                 if ((Renderer.context.ruleset() == RuleSet.ALL) || (Renderer.context.ruleset() == RuleSet.BASE)) {
                         if ((cat != CatSLC.SLC_SWAY) && (cat != CatSLC.SLC_TWAL)) {
                                 if (Renderer.zoom >= 12) {
-                                        Renderer.lineVector(feature, new LineStyle(Color.black, 10, Symbols.Yland));
+                                        Renderer.lineVector(new LineStyle(Color.black, 10, Symbols.Yland));
                                 } else {
-                                        Renderer.lineVector(feature, new LineStyle(Symbols.Yland));
+                                        Renderer.lineVector(new LineStyle(Symbols.Yland));
                                 }
                         }
@@ -1063 +1086 @@
                                 switch (cat) {
                                 case SLC_TWAL:
-                                        WatLEV lev = (WatLEV) getAttEnum(feature, feature.type, 0, Att.WATLEV);
+                                        WatLEV lev = (WatLEV) getAttEnum(feature.type, Att.WATLEV);
                                         if (lev == WatLEV.LEV_CVRS) {
-                                                Renderer.lineVector(feature, new LineStyle(Color.black, 10, new float[] { 40, 40 }, null));
+                                                Renderer.lineVector(new LineStyle(Color.black, 10, new float[] { 40, 40 }, null));
                                                 if (Renderer.zoom >= 15)
-                                                        Renderer.lineText(feature, "(covers)", new Font("Arial", Font.PLAIN, 60), Color.black, 0.5, 80);
+                                                        Renderer.lineText("(covers)", new Font("Arial", Font.PLAIN, 60), Color.black, 0.5, 80);
                                         } else {
-                                                Renderer.lineVector(feature, new LineStyle(Color.black, 10, null, null));
+                                                Renderer.lineVector(new LineStyle(Color.black, 10, null, null));
                                         }
                                         if (Renderer.zoom >= 15)
-                                                Renderer.lineText(feature, "Training Wall", new Font("Arial", Font.PLAIN, 60), Color.black, 0.5, -30);
+                                                Renderer.lineText("Training Wall", new Font("Arial", Font.PLAIN, 60), Color.black, 0.5, -30);
                                         break;
                                 case SLC_SWAY:
-                                        Renderer.lineVector(feature, new LineStyle(Color.black, 2, null, new Color(0xffe000)));
+                                        Renderer.lineVector(new LineStyle(Color.black, 2, null, new Color(0xffe000)));
                                         if ((Renderer.zoom >= 16) && feature.objs.containsKey(Obj.SMCFAC)) {
                                                 ArrayList<Symbol> symbols = new ArrayList<Symbol>();
-                                                ArrayList<CatSCF> scfs = (ArrayList<CatSCF>) getAttList(feature, Obj.SMCFAC, 0, Att.CATSCF);
+                                                ArrayList<CatSCF> scfs = (ArrayList<CatSCF>) getAttList(Obj.SMCFAC, Att.CATSCF);
                                                 for (CatSCF scf : scfs) {
                                                         symbols.add(Facilities.Cats.get(scf));
                                                 }
-                                                Renderer.cluster(feature, symbols);
+                                                Renderer.cluster(symbols);
                                         }
                                         break;
@@ -1098 +1121 @@
                         switch (feature.type) {
                         case SISTAT:
-                                Renderer.symbol(feature, Harbours.SignalStation);
+                                Renderer.symbol(Harbours.SignalStation);
                                 str = "SS";
-                                ArrayList<CatSIT> tcats = (ArrayList<CatSIT>) getAttList(feature, Obj.SISTAT, 0, Att.CATSIT);
+                                ArrayList<CatSIT> tcats = (ArrayList<CatSIT>) getAttList(Obj.SISTAT, Att.CATSIT);
                                 switch (tcats.get(0)) {
                                 case SIT_IPT:
@@ -1122 +1145 @@
                                 break;
                         case SISTAW:
-                                Renderer.symbol(feature, Harbours.SignalStation);
+                                Renderer.symbol(Harbours.SignalStation);
                                 str = "SS";
                                 str = "SS";
-                                ArrayList<CatSIW> wcats = (ArrayList<CatSIW>) getAttList(feature, Obj.SISTAW, 0, Att.CATSIW);
+                                ArrayList<CatSIW> wcats = (ArrayList<CatSIW>) getAttList(Obj.SISTAW, Att.CATSIW);
                                 switch (wcats.get(0)) {
                                 case SIW_STRM:
@@ -1163 +1186 @@
                         case RDOSTA:
                         case RTPBCN:
-                                Renderer.symbol(feature, Harbours.SignalStation);
-                                Renderer.symbol(feature, Beacons.RadarStation);
+                                Renderer.symbol(Harbours.SignalStation);
+                                Renderer.symbol(Beacons.RadarStation);
+                                break;
+                        case RADRFL:
+                                Renderer.symbol(Topmarks.RadarReflector);
                                 break;
                         case RADSTA:
-                                Renderer.symbol(feature, Harbours.SignalStation);
-                                Renderer.symbol(feature, Beacons.RadarStation);
-                                Renderer.labelText(feature, "Ra", new Font("Arial", Font.PLAIN, 40), Symbols.Msymb, new Delta(Handle.TR, AffineTransform.getTranslateInstance(-30, -70)));
+                                Renderer.symbol(Harbours.SignalStation);
+                                Renderer.symbol(Beacons.RadarStation);
+                                Renderer.labelText("Ra", new Font("Arial", Font.PLAIN, 40), Symbols.Msymb, new Delta(Handle.TR, AffineTransform.getTranslateInstance(-30, -70)));
                                 break;
                         case PILBOP:
-                                Renderer.symbol(feature, Harbours.Pilot);
-                                addName(feature, 15, new Font("Arial", Font.BOLD, 40), Symbols.Msymb , new Delta(Handle.LC, AffineTransform.getTranslateInstance(70, -40)));
-                                CatPIL cat = (CatPIL) getAttEnum(feature, feature.type, 0, Att.CATPIL);
+                                Renderer.symbol(Harbours.Pilot);
+                                addName(15, new Font("Arial", Font.BOLD, 40), Symbols.Msymb , new Delta(Handle.LC, AffineTransform.getTranslateInstance(70, -40)));
+                                CatPIL cat = (CatPIL) getAttEnum(feature.type, Att.CATPIL);
                                 if (cat == CatPIL.PIL_HELI) {
-                                        Renderer.labelText(feature, "H", new Font("Arial", Font.PLAIN, 40), Symbols.Msymb, new Delta(Handle.LC, AffineTransform.getTranslateInstance(70, 0)));
+                                        Renderer.labelText("H", new Font("Arial", Font.PLAIN, 40), Symbols.Msymb, new Delta(Handle.LC, AffineTransform.getTranslateInstance(70, 0)));
                                 }
                                 break;
                         case CGUSTA:
-                                Renderer.symbol(feature, Harbours.SignalStation);
+                                Renderer.symbol(Harbours.SignalStation);
                                 str = "CG";
-                          if (feature.objs.containsKey(Obj.RSCSTA)) Renderer.symbol(feature, Harbours.Rescue, new Delta(Handle.CC, AffineTransform.getTranslateInstance(130, 0)));
+                          if (feature.objs.containsKey(Obj.RSCSTA)) Renderer.symbol(Harbours.Rescue, new Delta(Handle.CC, AffineTransform.getTranslateInstance(130, 0)));
                                 break;
                         case RSCSTA:
-                                Renderer.symbol(feature, Harbours.Rescue);
+                                Renderer.symbol(Harbours.Rescue);
                                 break;
                         default:
@@ -1191 +1217 @@
                         }
                         if ((Renderer.zoom >= 15) && !str.isEmpty()) {
-                                Renderer.labelText(feature, str, new Font("Arial", Font.PLAIN, 40), Color.black, new Delta(Handle.LC, AffineTransform.getTranslateInstance(40, 0)));
-                        }
-                        Signals.addSignals(feature);
+                                Renderer.labelText(str, new Font("Arial", Font.PLAIN, 40), Color.black, new Delta(Handle.LC, AffineTransform.getTranslateInstance(40, 0)));
+                        }
+                        Signals.addSignals();
                 }
         }
@@ -1199 +1225 @@
         private static void transits() {
           if (Renderer.zoom >= 14) {
-                if (feature.type == Obj.RECTRC) Renderer.lineVector (feature, new LineStyle(Color.black, 10, null, null));
-                else if (feature.type == Obj.NAVLNE) Renderer.lineVector (feature, new LineStyle(Color.black, 10, new float[] { 25, 25 }, null));
+                if (feature.type == Obj.RECTRC) Renderer.lineVector (new LineStyle(Color.black, 10, null, null));
+                else if (feature.type == Obj.NAVLNE) Renderer.lineVector (new LineStyle(Color.black, 10, new float[] { 25, 25 }, null));
           }
                 if (Renderer.zoom >= 15) {
@@ -1208 +1234 @@
                                 str += name + " ";
                         Double ort;
-                        if ((ort = (Double) getAttVal(feature, feature.type, 0, Att.ORIENT)) != null) {
-                                str += ort.toString() + "\u0152";
+                        if ((ort = (Double) getAttVal(feature.type, Att.ORIENT)) != null) {
+                                str += df.format(ort) + "º";
                                 if (!str.isEmpty())
-                                        Renderer.lineText(feature, str, new Font("Arial", Font.PLAIN, 80), Color.black, 0.5, -20);
+                                        Renderer.lineText(str, new Font("Arial", Font.PLAIN, 80), Color.black, 0.5, -20);
                         }
                 }
@@ -1217 +1243 @@
 
         private static void waterways() {
-                Renderer.lineVector(feature, new LineStyle(Symbols.Bwater, 20, (feature.geom.prim == Pflag.AREA) ? Symbols.Bwater : null));
+                Renderer.lineVector(new LineStyle(Symbols.Bwater, 20, (feature.geom.prim == Pflag.AREA) ? Symbols.Bwater : null));
         }
 
         private static void wrecks() {
                 if (Renderer.zoom >= 14) {
-                        switch ((CatWRK) getAttEnum(feature, feature.type, 0, Att.CATWRK)) {
+                        switch ((CatWRK) getAttEnum(feature.type, Att.CATWRK)) {
                         case WRK_DNGR:
                         case WRK_MSTS:
-                                Renderer.symbol(feature, Areas.WreckD);
+                                Renderer.symbol(Areas.WreckD);
                                 break;
                         case WRK_HULS:
-                                Renderer.symbol(feature, Areas.WreckS);
+                                Renderer.symbol(Areas.WreckS);
                                 break;
                         default:
-                                Renderer.symbol(feature, Areas.WreckND);
+                                Renderer.symbol(Areas.WreckND);
                         }
                 }

applications/editors/josm/plugins/seachart/src/render/Signals.java

@@ -84 +84 @@
         }
         
-        public static void addSignals(Feature feature) {
-          if (feature.objs.containsKey(Obj.FOGSIG)) fogSignals(feature);
-          if (feature.objs.containsKey(Obj.RTPBCN)) radarStations(feature);
-          if (feature.objs.containsKey(Obj.RADSTA)) radarStations(feature);
-          if (feature.objs.containsKey(Obj.RDOSTA)) radioStations(feature);
-          if (feature.objs.containsKey(Obj.LIGHTS)) lights(feature);
-        }
-        
         static final EnumMap<CatFOG, String> fogSignals = new EnumMap<CatFOG, String>(CatFOG.class);
         static {
@@ -108 +100 @@
         static final DecimalFormat df = new DecimalFormat("#.#");
         
-        public static void fogSignals(Feature feature) {
-                Renderer.symbol(feature, Beacons.FogSignal);
-                AttMap atts = feature.objs.get(Obj.FOGSIG).get(0);
-                String str = "";
-                if (atts.containsKey(Att.CATFOG)) {
-                        str += fogSignals.get(((ArrayList<?>)(atts.get(Att.CATFOG).val)).get(0));
-                }
-                if (atts.containsKey(Att.SIGGRP)) {
-                        str += "(" + atts.get(Att.SIGGRP).val + ")";
-                } else {
-                        str += " ";
-                }
-                if (atts.containsKey(Att.SIGPER)) {
-                        str += df.format(atts.get(Att.SIGPER).val) + "s";
-                }
-                if (atts.containsKey(Att.VALMXR)) {
-                        str += df.format(atts.get(Att.VALMXR).val) + "M";
-                }
-                if ((Renderer.zoom >= 15) && !str.isEmpty()) {
-                        Renderer.labelText(feature, str, new Font("Arial", Font.PLAIN, 40),Color.black, new Delta(Handle.TR, AffineTransform.getTranslateInstance(-60, -30)));
-                }
-        }
-
-        public static void radarStations(Feature feature) {
-                Renderer.symbol(feature, Beacons.RadarStation);
-                String bstr = "";
-                CatRTB cat = (CatRTB) Rules.getAttEnum(feature, Obj.RTPBCN, 0, Att.CATRTB);
-                String wal = Rules.getAttStr(feature, Obj.RTPBCN, 0, Att.RADWAL);
-                switch (cat) {
-                case RTB_RAMK:
-                        bstr += " Ramark";
-                        break;
-                case RTB_RACN:
-                        bstr += " Racon";
-                        String astr = Rules.getAttStr(feature, Obj.RTPBCN, 0, Att.SIGGRP);
-                        if (!astr.isEmpty()) {
-                                bstr += "(" + astr + ")";
-                        }
-                        Double per = (Double) Rules.getAttVal(feature, Obj.RTPBCN, 0, Att.SIGPER);
-                        Double mxr = (Double) Rules.getAttVal(feature, Obj.RTPBCN, 0, Att.VALMXR);
-                        if ((per != null) || (mxr != null)) {
-                                bstr += (astr.isEmpty() ? " " : "");
-                                if (per != null) bstr += (per != 0) ? per.toString() + "s" : "";
-                                if (mxr != null) bstr += (mxr != 0) ? mxr.toString() + "M" : "";
-                        }
-                        break;
-                default:
-                        break;
-                }
-                if (!wal.isEmpty()) {
-                        switch (wal) {
-                        case "0.03-X":
-                                bstr += "(3cm)";
+        public static void addSignals() {
+          if (Rules.feature.objs.containsKey(Obj.RADRFL)) reflectors();
+          if (Rules.feature.objs.containsKey(Obj.FOGSIG)) fogSignals();
+          if (Rules.feature.objs.containsKey(Obj.RTPBCN)) radarStations();
+          if (Rules.feature.objs.containsKey(Obj.RADSTA)) radarStations();
+          if (Rules.feature.objs.containsKey(Obj.RDOSTA)) radioStations();
+          if (Rules.feature.objs.containsKey(Obj.LIGHTS)) lights();
+        }
+
+        public static void reflectors() {
+                if (Renderer.zoom >= 14) {
+                        switch (Rules.feature.type) {
+                        case BCNLAT:
+                        case BCNCAR:
+                        case BCNISD:
+                        case BCNSAW:
+                        case BCNSPP:
+                        case LITFLT:
+                        case LITVES:
+                        case BOYINB:
+                                if ((Rules.feature.objs.containsKey(Obj.TOPMAR)) || (Rules.feature.objs.containsKey(Obj.DAYMAR))) {
+                                        Renderer.symbol(Topmarks.RadarReflector, new Delta(Handle.BC, AffineTransform.getTranslateInstance(0, -140)));
+                                } else {
+                                        Renderer.symbol(Topmarks.RadarReflector, new Delta(Handle.BC, AffineTransform.getTranslateInstance(0, -80)));
+                                }
                                 break;
-                        case "0.10-S":
-                                bstr += "(10cm)";
+                        case LITMAJ:
+                        case LITMIN:
+                                if ((Rules.feature.objs.containsKey(Obj.TOPMAR)) || (Rules.feature.objs.containsKey(Obj.DAYMAR))) {
+                                        Renderer.symbol(Topmarks.RadarReflector, new Delta(Handle.BC, AffineTransform.getTranslateInstance(0, -90)));
+                                } else {
+                                        Renderer.symbol(Topmarks.RadarReflector, new Delta(Handle.BC, AffineTransform.getTranslateInstance(0, -30)));
+                                }
                                 break;
-                        }
-                }
-                if ((Renderer.zoom >= 15) && !bstr.isEmpty()) {
-                        Renderer.labelText(feature, bstr, new Font("Arial", Font.PLAIN, 40), Symbols.Msymb, new Delta(Handle.TR, AffineTransform.getTranslateInstance(-30, -70)));
-                }
-        }
-
-        @SuppressWarnings("unchecked")
-        public static void radioStations(Feature feature) {
-                ArrayList<CatROS> cats = (ArrayList<CatROS>)Rules.getAttList(feature, Obj.RDOSTA, 0, Att.CATROS);
-                boolean vais = false;
-                String bstr = "";
-                for (CatROS ros : cats) {
-                        switch (ros) {
-                        case ROS_OMNI:
-                                bstr += " RC";
-                                break;
-                        case ROS_DIRL:
-                                bstr += " RD";
-                                break;
-                        case ROS_ROTP:
-                                bstr += " RW";
-                                break;
-                        case ROS_CNSL:
-                                bstr += " Consol";
-                                break;
-                        case ROS_RDF:
-                                bstr += " RG";
-                                break;
-                        case ROS_QTA:
-                                bstr += " R";
-                                break;
-                        case ROS_AERO:
-                                bstr += " AeroRC";
-                                break;
-                        case ROS_DECA:
-                                bstr += " Decca";
-                                break;
-                        case ROS_LORN:
-                                bstr += " Loran";
-                                break;
-                        case ROS_DGPS:
-                                bstr += " DGPS";
-                                break;
-                        case ROS_TORN:
-                                bstr += " Toran";
-                                break;
-                        case ROS_OMGA:
-                                bstr += " Omega";
-                                break;
-                        case ROS_SYLD:
-                                bstr += " Syledis";
-                                break;
-                        case ROS_CHKA:
-                                bstr += " Chiaka";
-                                break;
-                        case ROS_PCOM:
-                        case ROS_COMB:
-                        case ROS_FACS:
-                        case ROS_TIME:
-                                break;
-                        case ROS_PAIS:
-                        case ROS_SAIS:
-                                bstr += " AIS";
-                                break;
-                        case ROS_VAIS:
-                                vais = true;
-                                break;
-                        case ROS_VANC:
-                                vais = true;
-                                Renderer.symbol(feature, Topmarks.TopNorth, new Delta(Handle.BC, AffineTransform.getTranslateInstance(0, -25)));
-                                break;
-                        case ROS_VASC:
-                                vais = true;
-                                Renderer.symbol(feature, Topmarks.TopSouth, new Delta(Handle.BC, AffineTransform.getTranslateInstance(0, -25)));
-                                break;
-                        case ROS_VAEC:
-                                vais = true;
-                                Renderer.symbol(feature, Topmarks.TopEast, new Delta(Handle.BC, AffineTransform.getTranslateInstance(0, -25)));
-                                break;
-                        case ROS_VAWC:
-                                vais = true;
-                                Renderer.symbol(feature, Topmarks.TopWest, new Delta(Handle.BC, AffineTransform.getTranslateInstance(0, -25)));
-                                break;
-                        case ROS_VAPL:
-                                vais = true;
-                                Renderer.symbol(feature, Topmarks.TopCan, new Delta(Handle.BC, AffineTransform.getTranslateInstance(0, -25)));
-                                break;
-                        case ROS_VASL:
-                                vais = true;
-                                Renderer.symbol(feature, Topmarks.TopCone, new Delta(Handle.BC, AffineTransform.getTranslateInstance(0, -25)));
-                                break;
-                        case ROS_VAID:
-                                vais = true;
-                                Renderer.symbol(feature, Topmarks.TopIsol, new Delta(Handle.BC, AffineTransform.getTranslateInstance(0, -25)));
-                                break;
-                        case ROS_VASW:
-                                vais = true;
-                                Renderer.symbol(feature, Topmarks.TopSphere, new Delta(Handle.BC, AffineTransform.getTranslateInstance(0, -25)));
-                                break;
-                        case ROS_VASP:
-                                vais = true;
-                                Renderer.symbol(feature, Topmarks.TopX, new Delta(Handle.BC, AffineTransform.getTranslateInstance(0, -25)));
-                                break;
-                        case ROS_VAWK:
-                                vais = true;
-                                Renderer.symbol(feature, Topmarks.TopCross, new Delta(Handle.BC, AffineTransform.getTranslateInstance(0, -25)));
+                        case BOYLAT:
+                        case BOYCAR:
+                        case BOYISD:
+                        case BOYSAW:
+                        case BOYSPP:
+                                if ((Rules.feature.objs.containsKey(Obj.TOPMAR)) || (Rules.feature.objs.containsKey(Obj.DAYMAR))) {
+                                        if (Rules.testAttribute(Rules.feature.type, Att.BOYSHP, BoySHP.BOY_PILR) || Rules.testAttribute(Rules.feature.type, Att.BOYSHP, BoySHP.BOY_PILR)) {
+                                                Renderer.symbol(Topmarks.RadarReflector, new Delta(Handle.BC, AffineTransform.getTranslateInstance(45, -140)));
+                                        } else {
+                                                Renderer.symbol(Topmarks.RadarReflector, new Delta(Handle.BC, AffineTransform.getTranslateInstance(25, -80)));
+                                        }
+                                } else {
+                                        if (Rules.testAttribute(Rules.feature.type, Att.BOYSHP, BoySHP.BOY_PILR) || Rules.testAttribute(Rules.feature.type, Att.BOYSHP, BoySHP.BOY_PILR)) {
+                                                Renderer.symbol(Topmarks.RadarReflector, new Delta(Handle.BC, AffineTransform.getTranslateInstance(30, -100)));
+                                        } else {
+                                                Renderer.symbol(Topmarks.RadarReflector, new Delta(Handle.BC, AffineTransform.getTranslateInstance(10, -50)));
+                                        }
+                                }
                                 break;
                         default:
@@ -277 +157 @@
                         }
                 }
-                if (!vais) {
-                        Renderer.symbol(feature, Beacons.RadarStation);
+        }
+        
+        public static void fogSignals() {
+                if (Renderer.zoom >= 11)
+                        Renderer.symbol(Beacons.FogSignal);
+                if (Renderer.zoom >= 15) {
+                        AttMap atts = Rules.feature.objs.get(Obj.FOGSIG).get(0);
+                        String str = "";
+                        if (atts.containsKey(Att.CATFOG)) {
+                                str += fogSignals.get(((ArrayList<?>) (atts.get(Att.CATFOG).val)).get(0));
+                        }
+                        if (atts.containsKey(Att.SIGGRP)) {
+                                str += "(" + atts.get(Att.SIGGRP).val + ")";
+                        } else {
+                                str += " ";
+                        }
+                        if (atts.containsKey(Att.SIGPER)) {
+                                str += df.format(atts.get(Att.SIGPER).val) + "s";
+                        }
+                        if (atts.containsKey(Att.VALMXR)) {
+                                str += df.format(atts.get(Att.VALMXR).val) + "M";
+                        }
+                        if (!str.isEmpty()) {
+                                Renderer.labelText(str, new Font("Arial", Font.PLAIN, 40), Color.black, new Delta(Handle.TR, AffineTransform.getTranslateInstance(-60, -30)));
+                        }
+                }
+        }
+
+        public static void radarStations() {
+                if (Renderer.zoom >= 11)
+                        Renderer.symbol(Beacons.RadarStation);
+                if (Renderer.zoom >= 15) {
+                        String bstr = "";
+                        CatRTB cat = (CatRTB) Rules.getAttEnum(Obj.RTPBCN, Att.CATRTB);
+                        String wal = Rules.getAttStr(Obj.RTPBCN, Att.RADWAL);
+                        switch (cat) {
+                        case RTB_RAMK:
+                                bstr += " Ramark";
+                                break;
+                        case RTB_RACN:
+                                bstr += " Racon";
+                                String astr = Rules.getAttStr(Obj.RTPBCN, Att.SIGGRP);
+                                if (!astr.isEmpty()) {
+                                        bstr += "(" + astr + ")";
+                                }
+                                Double per = (Double) Rules.getAttVal(Obj.RTPBCN, Att.SIGPER);
+                                Double mxr = (Double) Rules.getAttVal(Obj.RTPBCN, Att.VALMXR);
+                                if ((per != null) || (mxr != null)) {
+                                        bstr += (astr.isEmpty() ? " " : "");
+                                        if (per != null)
+                                                bstr += (per != 0) ? per.toString() + "s" : "";
+                                        if (mxr != null)
+                                                bstr += (mxr != 0) ? mxr.toString() + "M" : "";
+                                }
+                                break;
+                        default:
+                                break;
+                        }
+                        if (!wal.isEmpty()) {
+                                switch (wal) {
+                                case "0.03-X":
+                                        bstr += "(3cm)";
+                                        break;
+                                case "0.10-S":
+                                        bstr += "(10cm)";
+                                        break;
+                                }
+                        }
+                        if (!bstr.isEmpty()) {
+                                Renderer.labelText(bstr, new Font("Arial", Font.PLAIN, 40), Symbols.Msymb, new Delta(Handle.TR, AffineTransform.getTranslateInstance(-30, -70)));
+                        }
+                }
+        }
+
+        @SuppressWarnings("unchecked")
+        public static void radioStations() {
+                boolean vais = false;
+                String bstr = "";
+                if (Renderer.zoom >= 11) {
+                        ArrayList<CatROS> cats = (ArrayList<CatROS>) Rules.getAttList(Obj.RDOSTA, Att.CATROS);
+                        for (CatROS ros : cats) {
+                                switch (ros) {
+                                case ROS_OMNI:
+                                        bstr += " RC";
+                                        break;
+                                case ROS_DIRL:
+                                        bstr += " RD";
+                                        break;
+                                case ROS_ROTP:
+                                        bstr += " RW";
+                                        break;
+                                case ROS_CNSL:
+                                        bstr += " Consol";
+                                        break;
+                                case ROS_RDF:
+                                        bstr += " RG";
+                                        break;
+                                case ROS_QTA:
+                                        bstr += " R";
+                                        break;
+                                case ROS_AERO:
+                                        bstr += " AeroRC";
+                                        break;
+                                case ROS_DECA:
+                                        bstr += " Decca";
+                                        break;
+                                case ROS_LORN:
+                                        bstr += " Loran";
+                                        break;
+                                case ROS_DGPS:
+                                        bstr += " DGPS";
+                                        break;
+                                case ROS_TORN:
+                                        bstr += " Toran";
+                                        break;
+                                case ROS_OMGA:
+                                        bstr += " Omega";
+                                        break;
+                                case ROS_SYLD:
+                                        bstr += " Syledis";
+                                        break;
+                                case ROS_CHKA:
+                                        bstr += " Chiaka";
+                                        break;
+                                case ROS_PCOM:
+                                case ROS_COMB:
+                                case ROS_FACS:
+                                case ROS_TIME:
+                                        break;
+                                case ROS_PAIS:
+                                case ROS_SAIS:
+                                        bstr += " AIS";
+                                        break;
+                                case ROS_VAIS:
+                                        vais = true;
+                                        break;
+                                case ROS_VANC:
+                                        vais = true;
+                                        Renderer.symbol(Topmarks.TopNorth, new Delta(Handle.BC, AffineTransform.getTranslateInstance(0, -25)));
+                                        break;
+                                case ROS_VASC:
+                                        vais = true;
+                                        Renderer.symbol(Topmarks.TopSouth, new Delta(Handle.BC, AffineTransform.getTranslateInstance(0, -25)));
+                                        break;
+                                case ROS_VAEC:
+                                        vais = true;
+                                        Renderer.symbol(Topmarks.TopEast, new Delta(Handle.BC, AffineTransform.getTranslateInstance(0, -25)));
+                                        break;
+                                case ROS_VAWC:
+                                        vais = true;
+                                        Renderer.symbol(Topmarks.TopWest, new Delta(Handle.BC, AffineTransform.getTranslateInstance(0, -25)));
+                                        break;
+                                case ROS_VAPL:
+                                        vais = true;
+                                        Renderer.symbol(Topmarks.TopCan, new Delta(Handle.BC, AffineTransform.getTranslateInstance(0, -25)));
+                                        break;
+                                case ROS_VASL:
+                                        vais = true;
+                                        Renderer.symbol(Topmarks.TopCone, new Delta(Handle.BC, AffineTransform.getTranslateInstance(0, -25)));
+                                        break;
+                                case ROS_VAID:
+                                        vais = true;
+                                        Renderer.symbol(Topmarks.TopIsol, new Delta(Handle.BC, AffineTransform.getTranslateInstance(0, -25)));
+                                        break;
+                                case ROS_VASW:
+                                        vais = true;
+                                        Renderer.symbol(Topmarks.TopSphere, new Delta(Handle.BC, AffineTransform.getTranslateInstance(0, -25)));
+                                        break;
+                                case ROS_VASP:
+                                        vais = true;
+                                        Renderer.symbol(Topmarks.TopX, new Delta(Handle.BC, AffineTransform.getTranslateInstance(0, -25)));
+                                        break;
+                                case ROS_VAWK:
+                                        vais = true;
+                                        Renderer.symbol(Topmarks.TopCross, new Delta(Handle.BC, AffineTransform.getTranslateInstance(0, -25)));
+                                        break;
+                                default:
+                                        break;
+                                }
+                        }
+                        if (!vais) {
+                                Renderer.symbol(Beacons.RadarStation);
+                        }
                 }
                 if (Renderer.zoom >= 15) {
                         if (vais) {
-                                Renderer.labelText(feature, "V-AIS", new Font("Arial", Font.PLAIN, 40), Symbols.Msymb, new Delta(Handle.BC, AffineTransform.getTranslateInstance(0, 70)));
+                                Renderer.labelText("V-AIS", new Font("Arial", Font.PLAIN, 40), Symbols.Msymb, new Delta(Handle.BC, AffineTransform.getTranslateInstance(0, 70)));
                         }
                         if (!bstr.isEmpty()) {
-                                Renderer.labelText(feature, bstr, new Font("Arial", Font.PLAIN, 40), Symbols.Msymb, new Delta(Handle.TR, AffineTransform.getTranslateInstance(-30, -110)));
+                                Renderer.labelText(bstr, new Font("Arial", Font.PLAIN, 40), Symbols.Msymb, new Delta(Handle.TR, AffineTransform.getTranslateInstance(-30, -110)));
                         }
                 }
@@ -301 +362 @@
         
         @SuppressWarnings("unchecked")
-        public static void lights(Feature feature) {
+        public static void lights() {
                 Enum<ColCOL> col = null;
                 Enum<ColCOL> tcol = null;
-                ObjTab lights = feature.objs.get(Obj.LIGHTS);
+                ObjTab lights = Rules.feature.objs.get(Obj.LIGHTS);
                 for (AttMap atts : lights.values()) {
                         if (atts.containsKey(Att.COLOUR)) {
@@ -322 +383 @@
                         }
                 }
-                Renderer.symbol(feature, Beacons.LightFlare, new Scheme(LightColours.get(col)), new Delta(Handle.BC, AffineTransform.getRotateInstance(Math.toRadians(120))));
+                Renderer.symbol(Beacons.LightFlare, new Scheme(LightColours.get(col)), new Delta(Handle.BC, AffineTransform.getRotateInstance(Math.toRadians(120))));
                         String str = "";
                         if (lights.get(1) != null) {
@@ -425 +486 @@
                                         }
                                         if ((s1 <= 360) && (s2 <= 360) && (s1 != s2))
-                                                Renderer.lightSector(feature, LightColours.get(col1), LightColours.get(col2), radius, s1, s2, dir, (Renderer.zoom >= 15) ? str : "");
+                                                Renderer.lightSector(LightColours.get(col1), LightColours.get(col2), radius, s1, s2, dir, (Renderer.zoom >= 15) ? str : "");
                                 }
                         if (Renderer.zoom >= 15) {
@@ -432 +493 @@
                                         LitCHR chr;
                                         ColCOL col;
-                                        ColCOL alt;
                                         String grp;
                                         double per;
@@ -468 +528 @@
                                         ArrayList<ColCOL> cols = (ArrayList<ColCOL>) (atts.containsKey(Att.COLOUR) ? atts.get(Att.COLOUR).val : new ArrayList<>());
                                         sect.col = cols.size() > 0 ? cols.get(0) : ColCOL.COL_UNK;
-                                        sect.alt = cols.size() > 1 ? cols.get(1) : ColCOL.COL_UNK;
                                         if ((sect.chr != LitCHR.CHR_UNKN) && (sect.col != null))
                                                 litatts.add(sect);
@@ -552 +611 @@
                                         if (colrng.get(0).rng > 0)
                                                 str += df.format(colrng.get(0).rng) + ((colrng.size() > 1) ? ((colrng.size() > 2) ? ("-" + df.format(colrng.get(colrng.size() - 1).rng)) : ("/" + df.format(colrng.get(1).rng))) : "") + "M";
-                                        Renderer.labelText(feature, str, new Font("Arial", Font.PLAIN, 40), Color.black, new Delta(Handle.TL, AffineTransform.getTranslateInstance(60, y)));
+                                        Renderer.labelText(str, new Font("Arial", Font.PLAIN, 40), Color.black, new Delta(Handle.TL, AffineTransform.getTranslateInstance(60, y)));
                                         y += 40;
                                         str = "";
@@ -609 +668 @@
                                 str += (cats.contains(CatLIT.LIT_UPPR)) ? "(Upper)" : "";
                                 str += (cats.contains(CatLIT.LIT_LOWR)) ? "(Lower)" : "";
-                                Renderer.labelText(feature, str, new Font("Arial", Font.PLAIN, 40), Color.black, new Delta(Handle.TL, AffineTransform.getTranslateInstance(60, -30)));
+                                Renderer.labelText(str, new Font("Arial", Font.PLAIN, 40), Color.black, new Delta(Handle.TL, AffineTransform.getTranslateInstance(60, -30)));
                         }
                 }

applications/editors/josm/plugins/seachart/src/s57/S57map.java

@@ -466 +466 @@
                                         }
                                 } else {
-                                        Att att = S57att.enumAttribute(subkeys[1], Obj.UNKOBJ);
-                                        if (att != Att.UNKATT) {
-                                                AttVal<?> attval = S57val.convertValue(val, att);
-                                                if (attval.val != null)
-                                                        feature.atts.put(att, attval);
+                                        if (obj != Obj.UNKOBJ) {
+                                                if (val.equals("yes")) {
+                                                        ObjTab objs = feature.objs.get(obj);
+                                                        if (objs == null) {
+                                                                objs = new ObjTab();
+                                                                feature.objs.put(obj, objs);
+                                                        }
+                                                }
+                                        } else {
+                                                Att att = S57att.enumAttribute(subkeys[1], Obj.UNKOBJ);
+                                                if (att != Att.UNKATT) {
+                                                        AttVal<?> attval = S57val.convertValue(val, att);
+                                                        if (attval.val != null)
+                                                                feature.atts.put(att, attval);
+                                                }
                                         }
                                 }

applications/editors/josm/plugins/seachart/src/symbols/Symbols.java

@@ -25 +25 @@
         public static final Color Mline = new Color(0x9a6078);
         public static final Color Msymb = new Color(0xa30075);
+        public static final Color Mtss = new Color(0x80c480ff, true);
         
         public enum Form {

applications/editors/josm/plugins/seachart/src/symbols/Topmarks.java

@@ -20 +20 @@
 public class Topmarks {
         
+        public static final Symbol RadarReflector = new Symbol();
+        static {
+                RadarReflector.add(new Instr(Form.BBOX, new Rectangle2D.Double(-50,-40,100,40)));
+                RadarReflector.add(new Instr(Form.STRK, new BasicStroke(6, BasicStroke.CAP_BUTT, BasicStroke.JOIN_MITER)));
+                RadarReflector.add(new Instr(Form.FILL, Color.black));
+                Path2D.Double p = new Path2D.Double(); p.moveTo(-30,-3); p.quadTo(0, -40, 30, -3); p.moveTo(0,-20); p.lineTo(0,-37);
+                p.moveTo(-30, -3); p.lineTo(-43,-14); p.moveTo(30, -3); p.lineTo(44,-14); p.moveTo(-15, -14); p.lineTo(-25,-30); p.moveTo(15, -14); p.lineTo(25,-30);
+                RadarReflector.add(new Instr(Form.PLIN, p));
+        }
         public static final Symbol TopBesom = new Symbol();
         static {