Ignore:
Timestamp:
2016-10-09T04:25:33+02:00 (9 years ago)
Author:
donvip
Message:

checkstyle

Location:
applications/editors/josm/plugins/seachartedit/src/panels
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • applications/editors/josm/plugins/seachartedit/src/panels/PanelMain.java

    r31060 r33030  
    1818import java.awt.event.ActionListener;
    1919import java.awt.image.BufferedImage;
    20 import java.io.*;
     20import java.io.IOException;
    2121import java.util.ArrayList;
    2222
    23 import javax.swing.*;
     23import javax.swing.ImageIcon;
     24import javax.swing.JButton;
     25import javax.swing.JFileChooser;
     26import javax.swing.JPanel;
     27import javax.swing.JTextArea;
     28import javax.swing.JTextField;
     29
     30import org.openstreetmap.josm.Main;
    2431
    2532import messages.Messages;
    26 
    27 import org.openstreetmap.josm.Main;
    28 
     33import s57.S57att.Att;
     34import s57.S57map.AttMap;
     35import s57.S57map.Feature;
     36import s57.S57obj.Obj;
    2937import s57.S57val.AttVal;
    30 import s57.S57att.*;
    31 import s57.S57obj.*;
    32 import s57.S57map.*;
    3338import scedit.SCeditAction;
    3439
    3540public class PanelMain extends JPanel {
    3641
    37         BufferedImage img;
    38         int w, h, z, f;
    39         JTextField wt, ht, zt, ft;
    40         public static JTextArea decode = null;
    41         public static JTextField messageBar = null;
    42         public JButton saveButton = null;
    43         private ActionListener alSave = new ActionListener() {
    44                 public void actionPerformed(java.awt.event.ActionEvent e) {
    45                 }
    46         };
    47         private JButton importButton = null;
    48         JFileChooser ifc = new JFileChooser(Main.pref.get("nceditplugin.encinpfile"));
    49         private ActionListener alImport = new ActionListener() {
    50                 public void actionPerformed(java.awt.event.ActionEvent e) {
    51                         if (e.getSource() == importButton) {
    52                                 SCeditAction.panelS57.setVisible(true);
     42    BufferedImage img;
     43    int w, h, z, f;
     44    JTextField wt, ht, zt, ft;
     45    public static JTextArea decode = null;
     46    public static JTextField messageBar = null;
     47    public JButton saveButton = null;
     48    private ActionListener alSave = new ActionListener() {
     49        @Override
     50        public void actionPerformed(java.awt.event.ActionEvent e) {
     51        }
     52    };
     53    private JButton importButton = null;
     54    JFileChooser ifc = new JFileChooser(Main.pref.get("nceditplugin.encinpfile"));
     55    private ActionListener alImport = new ActionListener() {
     56        @Override
     57        public void actionPerformed(java.awt.event.ActionEvent e) {
     58            if (e.getSource() == importButton) {
     59                SCeditAction.panelS57.setVisible(true);
    5360        setStatus("Select S-57 ENC file for import", Color.yellow);
    54                                 int returnVal = ifc.showOpenDialog(Main.parent);
    55                                 if (returnVal == JFileChooser.APPROVE_OPTION) {
    56                                         try {
    57                                                 Main.pref.put("smed2plugin.encinpfile", ifc.getSelectedFile().getPath());
    58                                                 SCeditAction.panelS57.startImport(ifc.getSelectedFile());
    59                                         } catch (IOException e1) {
    60                                                 SCeditAction.panelS57.setVisible(false);
    61                                                 setStatus("IO Exception", Color.red);
    62                                         }
    63                                 } else {
    64                                         SCeditAction.panelS57.setVisible(false);
    65                                         clrStatus();
    66                                 }
    67                         }
    68                 }
    69         };
    70 
    71         private JButton exportButton = null;
    72         final JFileChooser efc = new JFileChooser();
    73         private ActionListener alExport = new ActionListener() {
    74                 public void actionPerformed(java.awt.event.ActionEvent e) {
    75                         if (e.getSource() == exportButton) {
    76                                 SCeditAction.panelS57.setVisible(true);
     61                int returnVal = ifc.showOpenDialog(Main.parent);
     62                if (returnVal == JFileChooser.APPROVE_OPTION) {
     63                    try {
     64                        Main.pref.put("smed2plugin.encinpfile", ifc.getSelectedFile().getPath());
     65                        SCeditAction.panelS57.startImport(ifc.getSelectedFile());
     66                    } catch (IOException e1) {
     67                        SCeditAction.panelS57.setVisible(false);
     68                        setStatus("IO Exception", Color.red);
     69                    }
     70                } else {
     71                    SCeditAction.panelS57.setVisible(false);
     72                    clrStatus();
     73                }
     74            }
     75        }
     76    };
     77
     78    private JButton exportButton = null;
     79    final JFileChooser efc = new JFileChooser();
     80    private ActionListener alExport = new ActionListener() {
     81        @Override
     82        public void actionPerformed(java.awt.event.ActionEvent e) {
     83            if (e.getSource() == exportButton) {
     84                SCeditAction.panelS57.setVisible(true);
    7785        setStatus("Select S-57 ENC file for export", Color.yellow);
    7886        int returnVal = efc.showOpenDialog(Main.parent);
    7987        if (returnVal == JFileChooser.APPROVE_OPTION) {
    80                 try {
    81                                                 SCeditAction.panelS57.startExport(efc.getSelectedFile());
    82                                         } catch (IOException e1) {
    83                                                 SCeditAction.panelS57.setVisible(false);
    84                                                 setStatus("IO Exception", Color.red);
    85                                         }
     88            try {
     89                        SCeditAction.panelS57.startExport(efc.getSelectedFile());
     90                    } catch (IOException e1) {
     91                        SCeditAction.panelS57.setVisible(false);
     92                        setStatus("IO Exception", Color.red);
     93                    }
    8694         } else {
    87                                         SCeditAction.panelS57.setVisible(false);
    88                                         clrStatus();
     95                     SCeditAction.panelS57.setVisible(false);
     96                    clrStatus();
    8997         }
    9098      }
    91                 }
    92         };
    93 
    94         public PanelMain() {
    95                 setLayout(null);
    96                 setSize(new Dimension(480, 480));
    97                
    98                 w = h = z = f = 0;
    99                 wt = new JTextField("0");
    100                 wt.setBounds(10, 400, 40, 20);
     99        }
     100    };
     101
     102    public PanelMain() {
     103        setLayout(null);
     104        setSize(new Dimension(480, 480));
     105
     106        w = h = z = f = 0;
     107        wt = new JTextField("0");
     108        wt.setBounds(10, 400, 40, 20);
    101109    add(wt);
    102                 ht = new JTextField("0");
    103                 ht.setBounds(60, 400, 40, 20);
     110        ht = new JTextField("0");
     111        ht.setBounds(60, 400, 40, 20);
    104112    add(ht);
    105                 zt = new JTextField("0");
    106                 zt.setBounds(110, 400, 40, 20);
     113        zt = new JTextField("0");
     114        zt.setBounds(110, 400, 40, 20);
    107115    add(zt);
    108                 ft = new JTextField("0");
    109                 ft.setBounds(160, 400, 40, 20);
     116        ft = new JTextField("0");
     117        ft.setBounds(160, 400, 40, 20);
    110118    add(ft);
    111119
    … …  
    115123    messageBar.setBackground(Color.WHITE);
    116124    add(messageBar);
    117                 importButton = new JButton(new ImageIcon(getClass().getResource("/images/importButton.png")));
    118                 importButton.setBounds(10, 430, 20, 20);
    119                 add(importButton);
    120                 importButton.addActionListener(alImport);
    121                 exportButton = new JButton(new ImageIcon(getClass().getResource("/images/exportButton.png")));
    122                 exportButton.setBounds(40, 430, 20, 20);
    123                 add(exportButton);
    124                 exportButton.addActionListener(alExport);
    125                 saveButton = new JButton();
    126                 saveButton.setBounds(370, 430, 100, 20);
    127                 saveButton.setText(tr("Save"));
    128                 add(saveButton);
    129                 saveButton.addActionListener(alSave);
    130 
    131                 decode = new JTextArea();
    132                 decode.setBounds(0, 0, 480, 420);
    133                 decode.setTabSize(1);
    134                 add(decode);
    135         }
    136        
    137         public void paintComponent(Graphics g){
    138                 super.paintComponent(g);
    139                 Graphics2D g2 = (Graphics2D) g;
    140                 g2.setBackground(new Color(0xb5d0d0));
    141                 if (img != null) g2.clearRect(0, 0, img.getWidth(), img.getHeight());
    142                 g2.drawImage(img, 0, 0, null);
    143         }
    144        
    145         public static void setStatus(String text, Color bg) {
    146                 messageBar.setBackground(bg);
    147                 messageBar.setText(text);
    148         }
    149        
    150         public static void clrStatus() {
    151                 messageBar.setBackground(Color.white);
    152                 messageBar.setText("");
    153         }
    154        
    155         public void parseMark(Feature feature) {
    156                 decode.setText("Selected object:\n");
    157                 decode.append("\t" + tr("Type") + ": " + Messages.getString(feature.type.name()) + "\n");
    158                 if (feature.atts.get(Att.OBJNAM) != null) {
    159                         decode.append("\t" + tr("Name") + ": " + feature.atts.get(Att.OBJNAM).val + "\n");
    160                 }
    161                 decode.append("\tObjects:\n");
    162                 for (Obj obj : feature.objs.keySet()) {
    163                         decode.append("\t\t" + Messages.getString(obj.name()) + "\n");
    164                         if (feature.objs.get(obj).size() != 0) {
    165                                 for (AttMap atts : feature.objs.get(obj).values()) {
    166                                         for (Att att : atts.keySet()) {
    167                                                 AttVal<?> item = atts.get(att);
    168                                                 switch (item.conv) {
    169                                                 case E:
    170                                                         decode.append("\t\t\t" + Messages.getString(att.name()) + ": " + Messages.getString(((Enum<?>)((ArrayList<?>)item.val).get(0)).name()) + "\n");
    171                                                         break;
    172                                                 case L:
    173                                                         decode.append("\t\t\t" + Messages.getString(att.name()) + ": ");
    174                                                         boolean first = true;
    175                                                         for (Object val : (ArrayList<?>)item.val) {
    176                                                                 if (!first) {
    177                                                                         decode.append(", ");
    178                                                                 } else {
    179                                                                         first = false;
    180                                                                 }
    181                                                                 decode.append(Messages.getString(((Enum<?>)val).name()));
    182                                                         }
    183                                                         decode.append("\n");
    184                                                         break;
    185                                                 default:
    186                                                         decode.append("\t\t\t" + Messages.getString(att.name()) + ": " + item.val + "\n");
    187                                                 }
    188                                         }
    189                                 }
    190                         }
    191                 }
    192         }
    193        
    194         public void clearMark() {
    195                 decode.setText(tr("No object selected"));
    196         }
    197        
     125        importButton = new JButton(new ImageIcon(getClass().getResource("/images/importButton.png")));
     126        importButton.setBounds(10, 430, 20, 20);
     127        add(importButton);
     128        importButton.addActionListener(alImport);
     129        exportButton = new JButton(new ImageIcon(getClass().getResource("/images/exportButton.png")));
     130        exportButton.setBounds(40, 430, 20, 20);
     131        add(exportButton);
     132        exportButton.addActionListener(alExport);
     133        saveButton = new JButton();
     134        saveButton.setBounds(370, 430, 100, 20);
     135        saveButton.setText(tr("Save"));
     136        add(saveButton);
     137        saveButton.addActionListener(alSave);
     138
     139        decode = new JTextArea();
     140        decode.setBounds(0, 0, 480, 420);
     141        decode.setTabSize(1);
     142        add(decode);
     143    }
     144
     145    @Override
     146    public void paintComponent(Graphics g) {
     147        super.paintComponent(g);
     148        Graphics2D g2 = (Graphics2D) g;
     149        g2.setBackground(new Color(0xb5d0d0));
     150        if (img != null) g2.clearRect(0, 0, img.getWidth(), img.getHeight());
     151        g2.drawImage(img, 0, 0, null);
     152    }
     153
     154    public static void setStatus(String text, Color bg) {
     155        messageBar.setBackground(bg);
     156        messageBar.setText(text);
     157    }
     158
     159    public static void clrStatus() {
     160        messageBar.setBackground(Color.white);
     161        messageBar.setText("");
     162    }
     163
     164    public void parseMark(Feature feature) {
     165        decode.setText("Selected object:\n");
     166        decode.append("\t" + tr("Type") + ": " + Messages.getString(feature.type.name()) + "\n");
     167        if (feature.atts.get(Att.OBJNAM) != null) {
     168            decode.append("\t" + tr("Name") + ": " + feature.atts.get(Att.OBJNAM).val + "\n");
     169        }
     170        decode.append("\tObjects:\n");
     171        for (Obj obj : feature.objs.keySet()) {
     172            decode.append("\t\t" + Messages.getString(obj.name()) + "\n");
     173            if (feature.objs.get(obj).size() != 0) {
     174                for (AttMap atts : feature.objs.get(obj).values()) {
     175                    for (Att att : atts.keySet()) {
     176                        AttVal<?> item = atts.get(att);
     177                        switch (item.conv) {
     178                        case E:
     179                            decode.append("\t\t\t" + Messages.getString(att.name()) + ": " +
     180                                    Messages.getString(((Enum<?>) ((ArrayList<?>) item.val).get(0)).name()) + "\n");
     181                            break;
     182                        case L:
     183                            decode.append("\t\t\t" + Messages.getString(att.name()) + ": ");
     184                            boolean first = true;
     185                            for (Object val : (ArrayList<?>) item.val) {
     186                                if (!first) {
     187                                    decode.append(", ");
     188                                } else {
     189                                    first = false;
     190                                }
     191                                decode.append(Messages.getString(((Enum<?>) val).name()));
     192                            }
     193                            decode.append("\n");
     194                            break;
     195                        default:
     196                            decode.append("\t\t\t" + Messages.getString(att.name()) + ": " + item.val + "\n");
     197                        }
     198                    }
     199                }
     200            }
     201        }
     202    }
     203
     204    public void clearMark() {
     205        decode.setText(tr("No object selected"));
     206    }
    198207}

  • applications/editors/josm/plugins/seachartedit/src/panels/PanelS57.java

    r32370 r33030  
    1212import java.awt.Color;
    1313import java.awt.Dimension;
    14 import java.io.*;
     14import java.io.File;
     15import java.io.FileInputStream;
     16import java.io.IOException;
    1517import java.util.ArrayList;
    1618import java.util.HashMap;
    … …  
    2426import org.openstreetmap.josm.data.Bounds;
    2527import org.openstreetmap.josm.data.coor.LatLon;
    26 import org.openstreetmap.josm.data.osm.*;
     28import org.openstreetmap.josm.data.osm.DataSet;
     29import org.openstreetmap.josm.data.osm.Node;
     30import org.openstreetmap.josm.data.osm.OsmPrimitive;
     31import org.openstreetmap.josm.data.osm.OsmPrimitiveType;
     32import org.openstreetmap.josm.data.osm.Relation;
     33import org.openstreetmap.josm.data.osm.RelationMember;
     34import org.openstreetmap.josm.data.osm.Way;
    2735import org.openstreetmap.josm.gui.layer.OsmDataLayer;
    2836
    2937import s57.S57att;
     38import s57.S57att.Att;
    3039import s57.S57dec;
     40import s57.S57map;
     41import s57.S57map.AttMap;
     42import s57.S57map.Feature;
     43import s57.S57map.GeomIterator;
     44import s57.S57map.ObjTab;
     45import s57.S57map.Pflag;
     46import s57.S57map.Prim;
     47import s57.S57map.Rflag;
     48import s57.S57map.Snode;
    3149import s57.S57obj;
    32 import s57.S57map;
     50import s57.S57obj.Obj;
    3351import s57.S57val;
    34 import s57.S57att.Att;
    35 import s57.S57map.*;
    36 import s57.S57obj.*;
    3752import s57.S57val.AttVal;
    3853
    3954public class PanelS57 extends JPanel {
    4055
    41         ArrayList<Obj> types = new ArrayList<Obj>();
    42         S57map map;
    43         HashMap<Long, Long> uids = new HashMap<Long, Long>();
    44        
    45         public PanelS57() {
    46                 setLayout(null);
    47                 setSize(new Dimension(480, 480));
    48                 setVisible(false);
    49         }
    50 
    51         public void startImport(File inf) throws IOException {
    52                 FileInputStream in = new FileInputStream(inf);
    53                 PanelMain.setStatus("Select OSM types file", Color.yellow);
    54                 JFileChooser ifc = new JFileChooser(Main.pref.get("smed2plugin.typesfile"));
    55                 ifc.setSelectedFile(new File(Main.pref.get("smed2plugin.typesfile")));
    56                 int returnVal = ifc.showOpenDialog(Main.parent);
    57                 if (returnVal == JFileChooser.APPROVE_OPTION) {
    58                         Main.pref.put("smed2plugin.typesfile", ifc.getSelectedFile().getPath());
    59                         Scanner tin = new Scanner(new FileInputStream(ifc.getSelectedFile()));
    60                         while (tin.hasNext()) {
    61                                 Obj type = S57obj.enumType(tin.next());
    62                                 if (type != Obj.UNKOBJ)
    63                                         types.add(type);
    64                         }
    65                         tin.close();
    66                 }
    67                 map = new S57map(true);
    68                 S57dec.decodeChart(in, map);
    69 
    70                 in.close();
    71                
    72                 DataSet data = new DataSet();
    73                 data.setUploadDiscouraged(true);
    74                
    75                 for (long id : map.index.keySet()) {
    76                         Feature feature = map.index.get(id);
    77                         String type = S57obj.stringType(feature.type);
    78                         if (!type.isEmpty() && (types.isEmpty() || types.contains(feature.type))) {
    79                                 if (feature.reln == Rflag.MASTER) {
    80                                         if (feature.geom.prim == Pflag.POINT) {
    81                                                 for (Prim prim : feature.geom.elems) {
    82                                                         long ref = prim.id;
    83                                                         Snode snode;
    84                                                         while ((snode = map.nodes.get(ref)) != null) {
    85                                                                 if (!uids.containsKey(ref)) {
    86                                                                         Node node = new Node(0, 1);
    87                                                                         node.setCoor((new LatLon(Math.toDegrees(snode.lat), Math.toDegrees(snode.lon))));
    88                                                                         data.addPrimitive(node);
    89                                                                         addKeys(node, feature, type);
    90                                                                         uids.put(ref, node.getUniqueId());
    91                                                                 }
    92                                                                 ref++;
    93                                                         }
    94                                                 }
    95                                         }
    96                                 }
    97                         }
    98                 }
    99                 for (long id : map.index.keySet()) {
    100                         Feature feature = map.index.get(id);
    101                         String type = S57obj.stringType(feature.type);
    102                         if (!type.isEmpty() && (types.isEmpty() || types.contains(feature.type))) {
    103                                 if (feature.reln == Rflag.MASTER) {
    104                                         if ((feature.geom.prim == Pflag.LINE) || ((feature.geom.prim == Pflag.AREA) && (feature.geom.outers == 1) && (feature.geom.inners == 0))) {
    105                                                 GeomIterator git = map.new GeomIterator(feature.geom);
    106                                                 while (git.hasComp()) {
    107                                                         git.nextComp();
    108                                                         while (git.hasEdge()) {
    109                                                                 git.nextEdge();
    110                                                                 while (git.hasNode()) {
    111                                                                         long ref = git.nextRef();
    112                                                                         Snode snode = map.nodes.get(ref);
    113                                                                         if (!uids.containsKey(ref)) {
    114                                                                                 Node node = new Node(0, 1);
    115                                                                                 node.setCoor((new LatLon(Math.toDegrees(snode.lat), Math.toDegrees(snode.lon))));
    116                                                                                 data.addPrimitive(node);
    117                                                                                 uids.put(ref, node.getUniqueId());
    118                                                                         }
    119                                                                 }
    120                                                         }
    121                                                 }
    122                                                 git = map.new GeomIterator(feature.geom);
    123                                                 while (git.hasComp()) {
    124                                                         git.nextComp();
    125                                                         Way way = new Way(0, 1);
    126                                                         data.addPrimitive(way);
    127                                                         while (git.hasEdge()) {
    128                                                                 git.nextEdge();
    129                                                                 while (git.hasNode()) {
    130                                                                         long ref = git.nextRef();
    131                                                                         way.addNode((Node)data.getPrimitiveById(uids.get(ref), OsmPrimitiveType.NODE));
    132                                                                 }
    133                                                         }
    134                                                         addKeys(way, feature, type);
    135                                                 }
    136                                         } else if (feature.geom.prim == Pflag.AREA) {
    137                                                 GeomIterator git = map.new GeomIterator(feature.geom);
    138                                                 while (git.hasComp()) {
    139                                                         git.nextComp();
    140                                                         while (git.hasEdge()) {
    141                                                                 git.nextEdge();
    142                                                                 while (git.hasNode()) {
    143                                                                         long ref = git.nextRef();
    144                                                                         Snode snode = map.nodes.get(ref);
    145                                                                         if (!uids.containsKey(ref)) {
    146                                                                                 Node node = new Node(0, 1);
    147                                                                                 node.setCoor((new LatLon(Math.toDegrees(snode.lat), Math.toDegrees(snode.lon))));
    148                                                                                 data.addPrimitive(node);
    149                                                                                 uids.put(ref, node.getUniqueId());
    150                                                                         }
    151                                                                 }
    152                                                         }
    153                                                 }
    154                                                 git = map.new GeomIterator(feature.geom);
    155                                                 while (git.hasComp()) {
    156                                                         long ref = git.nextComp();
    157                                                         Way way = new Way(0, 1);
    158                                                         uids.put(ref, way.getUniqueId());
    159                                                         data.addPrimitive(way);
    160                                                         while (git.hasEdge()) {
    161                                                                 git.nextEdge();
    162                                                                 while (git.hasNode()) {
    163                                                                         ref = git.nextRef();
    164                                                                         way.addNode((Node) data.getPrimitiveById(uids.get(ref), OsmPrimitiveType.NODE));
    165                                                                 }
    166                                                         }
    167                                                 }
    168                                                 Relation rel = new Relation(0, 1);
    169                                                 data.addPrimitive(rel);
    170                                                 git = map.new GeomIterator(feature.geom);
    171                                                 int outers = feature.geom.outers;
    172                                                 while (git.hasComp()) {
    173                                                         long ref = git.nextComp();
    174                                                         if (outers-- > 0) {
    175                                                                 rel.addMember(new RelationMember("outer", (Way) data.getPrimitiveById(uids.get(ref), OsmPrimitiveType.WAY)));
    176                                                         } else {
    177                                                                 rel.addMember(new RelationMember("inner", (Way) data.getPrimitiveById(uids.get(ref), OsmPrimitiveType.WAY)));
    178                                                         }
    179                                                 }
    180                                                 addKeys(rel, feature, type);
    181                                         }
    182                                 }
    183                         }
    184                 }
    185 
    186                 OsmDataLayer layer = new OsmDataLayer(data, "S-57 Import", null);
    187                 Main.getLayerManager().addLayer(layer);
    188                 Main.map.mapView.zoomTo(new Bounds(Math.toDegrees(map.bounds.minlat), Math.toDegrees(map.bounds.minlon), Math.toDegrees(map.bounds.maxlat), Math.toDegrees(map.bounds.maxlon)));
    189                 PanelMain.setStatus("Import done", Color.green);
    190         }
    191 
    192         void addKeys(OsmPrimitive prim, Feature feature, String type) {
    193                 HashMap<String,String> keys = new HashMap<String,String>();
    194                 if (prim instanceof Relation) {
    195                         keys.put("type", "multipolygon");
    196                 }
    197                 keys.put("seamark:type", type);
    198                 if (feature.type == Obj.SOUNDG) {
    199                         Snode snode = map.nodes.get(feature.geom.elems.get(0).id);
    200                         if (snode.flg == S57map.Nflag.DPTH) {
    201                                 keys.put("seamark:sounding:depth", ((Double)((Snode)snode).val).toString());
    202                         }
    203                 }
    204                 for (Map.Entry<Att, AttVal<?>> item : feature.atts.entrySet()) {
    205                         String attstr = S57att.stringAttribute(item.getKey());
    206                         String valstr = S57val.stringValue(item.getValue(), item.getKey());
    207                         if (!attstr.isEmpty() && !valstr.isEmpty()) {
    208                                         keys.put(("seamark:" + type + ":" + attstr), valstr);
    209                         }
    210                 }
    211                 for (Obj obj : feature.objs.keySet()) {
    212                         ObjTab tab = feature.objs.get(obj);
    213                         for (int ix : tab.keySet()) {
    214                                 type = S57obj.stringType(obj);
    215                                 AttMap atts = tab.get(ix);
    216                                 for (Map.Entry<Att, AttVal<?>> item : atts.entrySet()) {
    217                                         String attstr = S57att.stringAttribute(item.getKey());
    218                                         String valstr = S57val.stringValue(item.getValue(), item.getKey());
    219                                         if (!attstr.isEmpty() && !valstr.isEmpty()) {
    220                                                 if ((ix == 0) && (tab.size() == 1)) {
    221                                                         keys.put(("seamark:" + type + ":" + attstr), valstr);
    222                                                 } else {
    223                                                         keys.put(("seamark:" + type + ":" + (ix+1) + ":" + attstr), valstr);
    224                                                 }
    225                                         }
    226                                 }
    227                         }
    228                 }
    229                 prim.setKeys(keys);
    230         }
    231 
    232        
    233         public void startExport(File outf) throws IOException {
    234                
    235         }
     56    ArrayList<Obj> types = new ArrayList<>();
     57    S57map map;
     58    HashMap<Long, Long> uids = new HashMap<>();
     59
     60    public PanelS57() {
     61        setLayout(null);
     62        setSize(new Dimension(480, 480));
     63        setVisible(false);
     64    }
     65
     66    public void startImport(File inf) throws IOException {
     67        FileInputStream in = new FileInputStream(inf);
     68        PanelMain.setStatus("Select OSM types file", Color.yellow);
     69        JFileChooser ifc = new JFileChooser(Main.pref.get("smed2plugin.typesfile"));
     70        ifc.setSelectedFile(new File(Main.pref.get("smed2plugin.typesfile")));
     71        int returnVal = ifc.showOpenDialog(Main.parent);
     72        if (returnVal == JFileChooser.APPROVE_OPTION) {
     73            Main.pref.put("smed2plugin.typesfile", ifc.getSelectedFile().getPath());
     74            Scanner tin = new Scanner(new FileInputStream(ifc.getSelectedFile()));
     75            while (tin.hasNext()) {
     76                Obj type = S57obj.enumType(tin.next());
     77                if (type != Obj.UNKOBJ)
     78                    types.add(type);
     79            }
     80            tin.close();
     81        }
     82        map = new S57map(true);
     83        S57dec.decodeChart(in, map);
     84
     85        in.close();
     86
     87        DataSet data = new DataSet();
     88        data.setUploadDiscouraged(true);
     89
     90        for (long id : map.index.keySet()) {
     91            Feature feature = map.index.get(id);
     92            String type = S57obj.stringType(feature.type);
     93            if (!type.isEmpty() && (types.isEmpty() || types.contains(feature.type))) {
     94                if (feature.reln == Rflag.MASTER) {
     95                    if (feature.geom.prim == Pflag.POINT) {
     96                        for (Prim prim : feature.geom.elems) {
     97                            long ref = prim.id;
     98                            Snode snode;
     99                            while ((snode = map.nodes.get(ref)) != null) {
     100                                if (!uids.containsKey(ref)) {
     101                                    Node node = new Node(0, 1);
     102                                    node.setCoor((new LatLon(Math.toDegrees(snode.lat), Math.toDegrees(snode.lon))));
     103                                    data.addPrimitive(node);
     104                                    addKeys(node, feature, type);
     105                                    uids.put(ref, node.getUniqueId());
     106                                }
     107                                ref++;
     108                            }
     109                        }
     110                    }
     111                }
     112            }
     113        }
     114        for (long id : map.index.keySet()) {
     115            Feature feature = map.index.get(id);
     116            String type = S57obj.stringType(feature.type);
     117            if (!type.isEmpty() && (types.isEmpty() || types.contains(feature.type))) {
     118                if (feature.reln == Rflag.MASTER) {
     119                    if ((feature.geom.prim == Pflag.LINE) || ((feature.geom.prim == Pflag.AREA)
     120                            && (feature.geom.outers == 1) && (feature.geom.inners == 0))) {
     121                        GeomIterator git = map.new GeomIterator(feature.geom);
     122                        while (git.hasComp()) {
     123                            git.nextComp();
     124                            while (git.hasEdge()) {
     125                                git.nextEdge();
     126                                while (git.hasNode()) {
     127                                    long ref = git.nextRef();
     128                                    Snode snode = map.nodes.get(ref);
     129                                    if (!uids.containsKey(ref)) {
     130                                        Node node = new Node(0, 1);
     131                                        node.setCoor((new LatLon(Math.toDegrees(snode.lat), Math.toDegrees(snode.lon))));
     132                                        data.addPrimitive(node);
     133                                        uids.put(ref, node.getUniqueId());
     134                                    }
     135                                }
     136                            }
     137                        }
     138                        git = map.new GeomIterator(feature.geom);
     139                        while (git.hasComp()) {
     140                            git.nextComp();
     141                            Way way = new Way(0, 1);
     142                            data.addPrimitive(way);
     143                            while (git.hasEdge()) {
     144                                git.nextEdge();
     145                                while (git.hasNode()) {
     146                                    long ref = git.nextRef();
     147                                    way.addNode((Node) data.getPrimitiveById(uids.get(ref), OsmPrimitiveType.NODE));
     148                                }
     149                            }
     150                            addKeys(way, feature, type);
     151                        }
     152                    } else if (feature.geom.prim == Pflag.AREA) {
     153                        GeomIterator git = map.new GeomIterator(feature.geom);
     154                        while (git.hasComp()) {
     155                            git.nextComp();
     156                            while (git.hasEdge()) {
     157                                git.nextEdge();
     158                                while (git.hasNode()) {
     159                                    long ref = git.nextRef();
     160                                    Snode snode = map.nodes.get(ref);
     161                                    if (!uids.containsKey(ref)) {
     162                                        Node node = new Node(0, 1);
     163                                        node.setCoor((new LatLon(Math.toDegrees(snode.lat), Math.toDegrees(snode.lon))));
     164                                        data.addPrimitive(node);
     165                                        uids.put(ref, node.getUniqueId());
     166                                    }
     167                                }
     168                            }
     169                        }
     170                        git = map.new GeomIterator(feature.geom);
     171                        while (git.hasComp()) {
     172                            long ref = git.nextComp();
     173                            Way way = new Way(0, 1);
     174                            uids.put(ref, way.getUniqueId());
     175                            data.addPrimitive(way);
     176                            while (git.hasEdge()) {
     177                                git.nextEdge();
     178                                while (git.hasNode()) {
     179                                    ref = git.nextRef();
     180                                    way.addNode((Node) data.getPrimitiveById(uids.get(ref), OsmPrimitiveType.NODE));
     181                                }
     182                            }
     183                        }
     184                        Relation rel = new Relation(0, 1);
     185                        data.addPrimitive(rel);
     186                        git = map.new GeomIterator(feature.geom);
     187                        int outers = feature.geom.outers;
     188                        while (git.hasComp()) {
     189                            long ref = git.nextComp();
     190                            if (outers-- > 0) {
     191                                rel.addMember(new RelationMember("outer", data.getPrimitiveById(uids.get(ref), OsmPrimitiveType.WAY)));
     192                            } else {
     193                                rel.addMember(new RelationMember("inner", data.getPrimitiveById(uids.get(ref), OsmPrimitiveType.WAY)));
     194                            }
     195                        }
     196                        addKeys(rel, feature, type);
     197                    }
     198                }
     199            }
     200        }
     201
     202        OsmDataLayer layer = new OsmDataLayer(data, "S-57 Import", null);
     203        Main.getLayerManager().addLayer(layer);
     204        Main.map.mapView.zoomTo(new Bounds(Math.toDegrees(map.bounds.minlat), Math.toDegrees(map.bounds.minlon),
     205                                           Math.toDegrees(map.bounds.maxlat), Math.toDegrees(map.bounds.maxlon)));
     206        PanelMain.setStatus("Import done", Color.green);
     207    }
     208
     209    void addKeys(OsmPrimitive prim, Feature feature, String type) {
     210        HashMap<String, String> keys = new HashMap<>();
     211        if (prim instanceof Relation) {
     212            keys.put("type", "multipolygon");
     213        }
     214        keys.put("seamark:type", type);
     215        if (feature.type == Obj.SOUNDG) {
     216            Snode snode = map.nodes.get(feature.geom.elems.get(0).id);
     217            if (snode.flg == S57map.Nflag.DPTH) {
     218                keys.put("seamark:sounding:depth", ((Double) snode.val).toString());
     219            }
     220        }
     221        for (Map.Entry<Att, AttVal<?>> item : feature.atts.entrySet()) {
     222            String attstr = S57att.stringAttribute(item.getKey());
     223            String valstr = S57val.stringValue(item.getValue(), item.getKey());
     224            if (!attstr.isEmpty() && !valstr.isEmpty()) {
     225                    keys.put(("seamark:" + type + ":" + attstr), valstr);
     226            }
     227        }
     228        for (Obj obj : feature.objs.keySet()) {
     229            ObjTab tab = feature.objs.get(obj);
     230            for (int ix : tab.keySet()) {
     231                type = S57obj.stringType(obj);
     232                AttMap atts = tab.get(ix);
     233                for (Map.Entry<Att, AttVal<?>> item : atts.entrySet()) {
     234                    String attstr = S57att.stringAttribute(item.getKey());
     235                    String valstr = S57val.stringValue(item.getValue(), item.getKey());
     236                    if (!attstr.isEmpty() && !valstr.isEmpty()) {
     237                        if ((ix == 0) && (tab.size() == 1)) {
     238                            keys.put(("seamark:" + type + ":" + attstr), valstr);
     239                        } else {
     240                            keys.put(("seamark:" + type + ":" + (ix+1) + ":" + attstr), valstr);
     241                        }
     242                    }
     243                }
     244            }
     245        }
     246        prim.setKeys(keys);
     247    }
     248
     249    public void startExport(File outf) throws IOException {
     250
     251    }
    236252}

  • applications/editors/josm/plugins/seachartedit/src/panels/ShowFrame.java

    r32231 r33030  
    2525import render.Renderer;
    2626import s57.S57map;
    27 import s57.S57map.*;
     27import s57.S57map.Feature;
     28import s57.S57map.Snode;
    2829
    2930public class ShowFrame extends JFrame {
    30        
    31         S57map showMap;
    32         Picture picture;
    3331
    34         class Picture extends JPanel implements ChartContext {
     32    S57map showMap;
     33    Picture picture;
    3534
    36                 public void drawPicture(OsmPrimitive osm, S57map map) {
    37                         long id;
    38                         Feature feature;
    39                        
    40                         id = osm.getUniqueId();
    41                         feature = map.index.get(id);
    42                         showMap = new S57map(true);
    43                         showMap.nodes = map.nodes;
    44                         showMap.edges = map.edges;
    45                         showMap.index = map.index;
    46                         if (feature != null) {
    47                                 showMap.features.put(feature.type, new ArrayList<Feature>());
    48                                 showMap.features.get(feature.type).add(feature);
    49                         }
    50                         repaint();
    51                 }
    52                
    53                 public void paintComponent(Graphics g) {
    54                         Graphics2D g2 = (Graphics2D)g;
    55                         g2.setBackground(new Color(0xb5d0d0));
    56                         Rectangle rect =  new Rectangle(0, 0, 300, 300);
    57                         g2.clearRect(rect.x, rect.y, rect.width, rect.height);
    58                         Renderer.reRender(g2, rect, 16, 32, showMap, this);
    59                 }
     35    class Picture extends JPanel implements ChartContext {
    6036
    61                 public Point2D getPoint(Snode coord) {
    62                         return new Point2D.Double(150, 150);
    63                 }
     37        public void drawPicture(OsmPrimitive osm, S57map map) {
     38            long id;
     39            Feature feature;
    6440
    65                 public double mile(Feature feature) {
    66                         return 1000;
    67                 }
     41            id = osm.getUniqueId();
     42            feature = map.index.get(id);
     43            showMap = new S57map(true);
     44            showMap.nodes = map.nodes;
     45            showMap.edges = map.edges;
     46            showMap.index = map.index;
     47            if (feature != null) {
     48                showMap.features.put(feature.type, new ArrayList<Feature>());
     49                showMap.features.get(feature.type).add(feature);
     50            }
     51            repaint();
     52        }
    6853
    69                 @Override
    70                 public boolean clip() {
    71                         // TODO Auto-generated method stub
    72                         return false;
    73                 }
     54        @Override
     55        public void paintComponent(Graphics g) {
     56            Graphics2D g2 = (Graphics2D) g;
     57            g2.setBackground(new Color(0xb5d0d0));
     58            Rectangle rect = new Rectangle(0, 0, 300, 300);
     59            g2.clearRect(rect.x, rect.y, rect.width, rect.height);
     60            Renderer.reRender(g2, rect, 16, 32, showMap, this);
     61        }
    7462
    75                 @Override
    76                 public Color background(S57map map) {
    77                         // TODO Auto-generated method stub
    78                         return null;
    79                 }
     63        @Override
     64        public Point2D getPoint(Snode coord) {
     65            return new Point2D.Double(150, 150);
     66        }
    8067
    81                 @Override
    82                 public RuleSet ruleset() {
    83                         // TODO Auto-generated method stub
    84                         return null;
    85                 }
    86         }
     68        @Override
     69        public double mile(Feature feature) {
     70            return 1000;
     71        }
    8772
    88         public ShowFrame(String title) {
    89                 super(title);
    90                 picture = new Picture();
    91                 picture.setVisible(true);
    92                 add(picture);
    93                 pack();
    94         }
    95        
    96         public void showFeature(OsmPrimitive osm, S57map map) {
    97                 picture.drawPicture(osm, map);
    98         }
     73        @Override
     74        public boolean clip() {
     75            // TODO Auto-generated method stub
     76            return false;
     77        }
     78
     79        @Override
     80        public Color background(S57map map) {
     81            // TODO Auto-generated method stub
     82            return null;
     83        }
     84
     85        @Override
     86        public RuleSet ruleset() {
     87            // TODO Auto-generated method stub
     88            return null;
     89        }
     90    }
     91
     92    public ShowFrame(String title) {
     93        super(title);
     94        picture = new Picture();
     95        picture.setVisible(true);
     96        add(picture);
     97        pack();
     98    }
     99
     100    public void showFeature(OsmPrimitive osm, S57map map) {
     101        picture.drawPicture(osm, map);
     102    }
    99103}
Note: See TracChangeset for help on using the changeset viewer.