Ignore:
Timestamp:
2016-07-07T23:55:57+02:00 (8 years ago)
Author:
donvip
Message:

checkstyle

Location:
applications/editors/josm/plugins/indoor_sweepline
Files:
1 added
13 edited

Legend:

Unmodified
Added
Removed

  • applications/editors/josm/plugins/indoor_sweepline/.project

    r32479 r32601  
    1717                        </arguments>
    1818                </buildCommand>
     19                <buildCommand>
     20                        <name>net.sf.eclipsecs.core.CheckstyleBuilder</name>
     21                        <arguments>
     22                        </arguments>
     23                </buildCommand>
    1924        </buildSpec>
    2025        <natures>
    2126                <nature>org.eclipse.jdt.core.javanature</nature>
     27                <nature>net.sf.eclipsecs.core.CheckstyleNature</nature>
    2228        </natures>
    2329</projectDescription>

  • applications/editors/josm/plugins/indoor_sweepline/build.xml

    r32479 r32601  
    55    <property name="commit.message" value="Commit message"/>
    66    <!-- enter the *lowest* JOSM version this plugin is currently compatible with -->
    7     <property name="plugin.main.version" value="10279"/>
     7    <property name="plugin.main.version" value="10420"/>
    88
    99    <property name="plugin.author" value="Roland M. Olbricht"/>

  • applications/editors/josm/plugins/indoor_sweepline/src/indoor_sweepline/Beam.java

    r32479 r32601  
     1// License: GPL. For details, see LICENSE file.
    12package indoor_sweepline;
    23
    34import java.util.Vector;
    45
    5 
    6 public class Beam
    7 {
    8     public Beam(Vector<Double> blueprint, double blueprintOffset, CorridorPart.ReachableSide defaultSide)
    9     {
     6public class Beam {
     7
     8    public Beam(Vector<Double> blueprint, double blueprintOffset, CorridorPart.ReachableSide defaultSide) {
    109        offset = blueprintOffset;
    1110        parts = new Vector<>();
    1211
    1312        setDefaultSide_(defaultSide);
    14         if (defaultSide == CorridorPart.ReachableSide.RIGHT)
    15         {
    16             for (int i = 1; i < blueprint.size(); i += 2)
    17             {
     13        if (defaultSide == CorridorPart.ReachableSide.RIGHT) {
     14            for (int i = 1; i < blueprint.size(); i += 2) {
    1815                addCorridorPart_(true, CorridorPart.Type.WALL,
    1916                        blueprint.elementAt(i).doubleValue() - blueprint.elementAt(i-1).doubleValue());
    … …  
    2219                            blueprint.elementAt(i+1).doubleValue() - blueprint.elementAt(i).doubleValue());
    2320            }
    24         }
    25         else
    26         {
    27             for (int i = 1; i < blueprint.size(); i += 2)
    28             {
     21        } else {
     22            for (int i = 1; i < blueprint.size(); i += 2) {
    2923                addCorridorPart_(true, CorridorPart.Type.PASSAGE,
    3024                        blueprint.elementAt(i).doubleValue() - blueprint.elementAt(i-1).doubleValue());
    … …  
    3731    }
    3832
    39 
    40     private void setDefaultSide_(CorridorPart.ReachableSide defaultSide)
    41     {
     33    private void setDefaultSide_(CorridorPart.ReachableSide defaultSide) {
    4234        this.defaultSide = defaultSide;
    4335    }
    4436
    45     public void setDefaultSide(CorridorPart.ReachableSide defaultSide)
    46     {
     37    public void setDefaultSide(CorridorPart.ReachableSide defaultSide) {
    4738        setDefaultSide_(defaultSide);
    4839        adjustStripCache();
    4940    }
    5041
    51 
    52     public Vector<CorridorPart> getBeamParts()
    53     {
     42    public Vector<CorridorPart> getBeamParts() {
    5443        return parts;
    5544    }
    5645
    57 
    58     public double getBeamOffset()
    59     {
     46    public double getBeamOffset() {
    6047        return offset;
    6148    }
    6249
    63     public void setBeamOffset(double beamOffset)
    64     {
     50    public void setBeamOffset(double beamOffset) {
    6551        offset = beamOffset;
    6652    }
    6753
    68 
    69     private void addCorridorPart_(boolean append, CorridorPart.Type type, double width)
    70     {
     54    private void addCorridorPart_(boolean append, CorridorPart.Type type, double width) {
    7155        CorridorPart.ReachableSide side = defaultSide == CorridorPart.ReachableSide.RIGHT ?
    7256                defaultSide : CorridorPart.ReachableSide.ALL;
    … …  
    7862    }
    7963
    80     public void addCorridorPart(boolean append, double width)
    81     {
     64    public void addCorridorPart(boolean append, double width) {
    8265        addCorridorPart_(append,
    8366                defaultSide == CorridorPart.ReachableSide.RIGHT ? CorridorPart.Type.WALL : CorridorPart.Type.PASSAGE,
    … …  
    8669    }
    8770
    88 
    89     public void setCorridorPartWidth(int partIndex, double value)
    90     {
     71    public void setCorridorPartWidth(int partIndex, double value) {
    9172        parts.elementAt(partIndex).width = value;
    9273        adjustStripCache();
    9374    }
    9475
    95 
    96     public void setCorridorPartType(int partIndex, CorridorPart.Type type)
    97     {
     76    public void setCorridorPartType(int partIndex, CorridorPart.Type type) {
    9877        parts.elementAt(partIndex).setType(type, defaultSide);
    9978        enforceSideCoherence();
    … …  
    10180    }
    10281
    103 
    104     public void setCorridorPartSide(int partIndex, CorridorPart.ReachableSide side)
    105     {
     82    public void setCorridorPartSide(int partIndex, CorridorPart.ReachableSide side) {
    10683        parts.elementAt(partIndex).setSide(side, defaultSide);
    10784        enforceSideCoherence();
    … …  
    10986    }
    11087
    111 
    112     private void enforceSideCoherence()
    113     {
    114         for (int i = 1; i < parts.size(); ++i)
    115         {
     88    private void enforceSideCoherence() {
     89        for (int i = 1; i < parts.size(); ++i) {
    11690            if (parts.elementAt(i).getSide() != CorridorPart.ReachableSide.ALL
    11791                    && parts.elementAt(i-1).getSide() != CorridorPart.ReachableSide.ALL)
    … …  
    12094    }
    12195
    122 
    123     private boolean isVoidAbove(int i)
    124     {
     96    private boolean isVoidAbove(int i) {
    12597        return i == 0 || parts.elementAt(i-1).getType() == CorridorPart.Type.VOID
    12698                || (parts.elementAt(i-1).getSide() == CorridorPart.ReachableSide.RIGHT
    … …  
    130102    }
    131103
    132     private boolean isVoidBelow(int i)
    133     {
     104    private boolean isVoidBelow(int i) {
    134105        return i == parts.size() || parts.elementAt(i).getType() == CorridorPart.Type.VOID
    135106                || (parts.elementAt(i).getSide() == CorridorPart.ReachableSide.RIGHT
    … …  
    139110    }
    140111
    141     private boolean isPassageAbove(int i)
    142     {
     112    private boolean isPassageAbove(int i) {
    143113        return i > 0
    144114                && parts.elementAt(i-1).getType() == CorridorPart.Type.PASSAGE
    … …  
    146116    }
    147117
    148     private boolean isPassageBelow(int i)
    149     {
     118    private boolean isPassageBelow(int i) {
    150119        return i < parts.size()
    151120                && parts.elementAt(i).getType() == CorridorPart.Type.PASSAGE
    … …  
    153122    }
    154123
    155     private boolean isReachableLeft(int i)
    156     {
     124    private boolean isReachableLeft(int i) {
    157125        if (defaultSide == CorridorPart.ReachableSide.RIGHT)
    158126            return false;
    … …  
    162130    }
    163131
    164 
    165     private void connectTwoPos(StripPosition newPos, boolean toLeft)
    166     {
     132    private void connectTwoPos(StripPosition newPos, boolean toLeft) {
    167133        StripPosition other = null;
    168         if (rhsStrips.size() > 0 && rhsStrips.elementAt(rhsStrips.size()-1).connectedTo == -1)
    169         {
     134        if (rhsStrips.size() > 0 && rhsStrips.elementAt(rhsStrips.size()-1).connectedTo == -1) {
    170135            newPos.connectedToSameSide = !toLeft;
    171136            newPos.connectedTo = rhsStrips.size()-1;
    172137            other = rhsStrips.elementAt(rhsStrips.size()-1);
    173         }
    174         else
    175         {
     138        } else {
    176139            newPos.connectedToSameSide = toLeft;
    177140            newPos.connectedTo = lhsStrips.size()-1;
    … …  
    180143
    181144        other.connectedToSameSide = newPos.connectedToSameSide;
    182         if (toLeft)
    183         {
     145        if (toLeft) {
    184146            other.connectedTo = lhsStrips.size();
    185147            lhsStrips.add(newPos);
    186         }
    187         else
    188         {
     148        } else {
    189149            other.connectedTo = rhsStrips.size();
    190150            rhsStrips.add(newPos);
    … …  
    192152    }
    193153
    194 
    195     private class StripPosition
    196     {
    197         StripPosition(int nodeIndex, double offset)
    198         {
     154    private class StripPosition {
     155        StripPosition(int nodeIndex, double offset) {
    199156            this.nodeIndex = nodeIndex;
    200157            this.offset = offset;
    … …  
    209166    }
    210167
    211 
    212168    private double offset;
    213169    private Vector<CorridorPart> parts;
    … …  
    215171    private Vector<StripPosition> rhsStrips;
    216172
    217 
    218     private void adjustStripCache()
    219     {
     173    private void adjustStripCache() {
    220174        lhsStrips = new Vector<>();
    221175        rhsStrips = new Vector<>();
    … …  
    223177        double offset = 0;
    224178
    225         for (int i = 0; i <= parts.size(); ++i)
    226         {
    227             if (isVoidBelow(i))
    228             {
    229                 if (isPassageAbove(i))
    230                 {
     179        for (int i = 0; i <= parts.size(); ++i) {
     180            if (isVoidBelow(i)) {
     181                if (isPassageAbove(i)) {
    231182                    StripPosition lhs = new StripPosition(i, offset);
    232183                    StripPosition rhs = new StripPosition(i, offset);
    … …  
    239190                    lhsStrips.add(lhs);
    240191                    rhsStrips.add(rhs);
    241                 }
    242                 else if (!isVoidAbove(i))
     192                } else if (!isVoidAbove(i))
    243193                    connectTwoPos(new StripPosition(i, offset), isReachableLeft(i-1));
    244             }
    245             else if (isPassageBelow(i))
    246             {
    247                 if (isVoidAbove(i))
    248                 {
     194            } else if (isPassageBelow(i)) {
     195                if (isVoidAbove(i)) {
    249196                    StripPosition lhs = new StripPosition(i, offset);
    250197                    StripPosition rhs = new StripPosition(i, offset);
    … …  
    257204                    lhsStrips.add(lhs);
    258205                    rhsStrips.add(rhs);
    259                 }
    260                 else if (!isPassageAbove(i))
     206                } else if (!isPassageAbove(i))
    261207                    connectTwoPos(new StripPosition(i, offset), !isReachableLeft(i-1));
    262             }
    263             else
    264             {
    265                 if (isVoidAbove(i))
    266                 {
     208            } else {
     209                if (isVoidAbove(i)) {
    267210                    if (isReachableLeft(i))
    268211                        lhsStrips.add(new StripPosition(i, offset));
    269212                    else
    270213                        rhsStrips.add(new StripPosition(i, offset));
    271                 }
    272                 else if (isPassageAbove(i))
    273                 {
     214                } else if (isPassageAbove(i)) {
    274215                    if (isReachableLeft(i))
    275216                        rhsStrips.add(new StripPosition(i, offset));
    … …  
    284225    }
    285226
    286 
    287     public Vector<Double> leftHandSideStrips()
    288     {
     227    public Vector<Double> leftHandSideStrips() {
    289228        Vector<Double> offsets = new Vector<>();
    290         for (StripPosition pos : lhsStrips)
     229        for (StripPosition pos : lhsStrips) {
    291230            offsets.add(pos.offset);
     231        }
    292232
    293233        return offsets;
    294234    }
    295235
    296 
    297     public Vector<Double> rightHandSideStrips()
    298     {
     236    public Vector<Double> rightHandSideStrips() {
    299237        Vector<Double> offsets = new Vector<>();
    300         for (StripPosition pos : rhsStrips)
     238        for (StripPosition pos : rhsStrips) {
    301239            offsets.add(pos.offset);
     240        }
    302241
    303242        return offsets;
    304243    }
    305244
    306 
    307     public int getBeamPartIndex(boolean toTheLeft, int i)
    308     {
     245    public int getBeamPartIndex(boolean toTheLeft, int i) {
    309246        if (toTheLeft)
    310247            return lhsStrips.elementAt(i).nodeIndex;
    … …  
    313250    }
    314251
    315 
    316252    public boolean appendNodes(IndoorSweeplineModel.SweepPolygonCursor cursor, boolean fromRight,
    317             BeamGeography geography, String level)
    318     {
    319         if (fromRight)
    320         {
     253            BeamGeography geography, String level) {
     254        if (fromRight) {
    321255            StripPosition pos = rhsStrips.elementAt(cursor.partIndex);
    322256            StripPosition to = pos.connectedToSameSide ?
    … …  
    330264
    331265                    return !pos.connectedToSameSide;
    332         }
    333         else
    334         {
     266        } else {
    335267            StripPosition pos = lhsStrips.elementAt(cursor.partIndex);
    336268            StripPosition to = pos.connectedToSameSide ?
    … …  
    347279    }
    348280
    349 
    350281    private CorridorPart.ReachableSide defaultSide;
    351282}

  • applications/editors/josm/plugins/indoor_sweepline/src/indoor_sweepline/BeamGeography.java

    r32479 r32601  
     1// License: GPL. For details, see LICENSE file.
    12package indoor_sweepline;
    23
    … …  
    78import org.openstreetmap.josm.data.osm.Node;
    89
     10public class BeamGeography {
    911
    10 public class BeamGeography
    11 {
    12     public BeamGeography(DataSet dataSet, ModelGeography target)
    13     {
     12    public BeamGeography(DataSet dataSet, ModelGeography target) {
    1413        partsGeography = new Vector<>();
    1514        nodes = new Vector<>();
    … …  
    1817    }
    1918
    20 
    21     public void appendNodes(int from, int to, String level)
    22     {
    23         if (from <= to)
    24         {
    25             for (int i = from; i < to; ++i)
    26             {
     19    public void appendNodes(int from, int to, String level) {
     20        if (from <= to) {
     21            for (int i = from; i < to; ++i) {
    2722                target.appendNode(nodes.elementAt(i));
    2823                CorridorPart part = parts.elementAt(i);
    … …  
    3126            }
    3227            target.appendNode(nodes.elementAt(to));
    33         }
    34         else
    35         {
    36             for (int i = from; i > to; --i)
    37             {
     28        } else {
     29            for (int i = from; i > to; --i) {
    3830                target.appendNode(nodes.elementAt(i));
    3931                CorridorPart part = parts.elementAt(i-1);
    … …  
    4537    }
    4638
    47 
    48     public void adjustNodes(LatLon pivot, Vector<CorridorPart> parts, double beamOffset)
    49     {
     39    public void adjustNodes(LatLon pivot, Vector<CorridorPart> parts, double beamOffset) {
    5040        double offset = -beamOffset;
    5141        this.parts = parts;
    … …  
    5343        adjustNode(0, new LatLon(addMetersToLat(pivot, offset), pivot.lon()));
    5444
    55         for (int i = 0; i < parts.size(); ++i)
    56         {
     45        for (int i = 0; i < parts.size(); ++i) {
    5746            adjustPartGeography(i);
    5847            offset += parts.elementAt(i).width;
    … …  
    6352    }
    6453
    65 
    66     private void adjustNode(int i, LatLon coor)
    67     {
     54    private void adjustNode(int i, LatLon coor) {
    6855        if (nodes.size() <= i)
    6956            nodes.setSize(i+1);
    7057        Node node = nodes.elementAt(i);
    71         if (node == null)
    72         {
     58        if (node == null) {
    7359            node = new Node(coor);
    7460            dataSet.addPrimitive(node);
    7561            nodes.setElementAt(node, i);
    76         }
    77         else
     62        } else
    7863            node.setCoor(coor);
    7964    }
    8065
    81 
    82     private void adjustPartGeography(int i)
    83     {
     66    private void adjustPartGeography(int i) {
    8467        if (partsGeography.size() <= i)
    8568            partsGeography.setSize(i+1);
    8669        CorridorGeography partGeography = partsGeography.elementAt(i);
    87         if (partGeography == null)
    88         {
     70        if (partGeography == null) {
    8971            partGeography = new CorridorGeography(dataSet);
    9072            partsGeography.setElementAt(partGeography, i);
    … …  
    9274    }
    9375
    94 
    95     public LatLon coorAt(int i)
    96     {
     76    public LatLon coorAt(int i) {
    9777        return nodes.elementAt(i).getCoor();
    9878    }
    99 
    10079
    10180    private Vector<CorridorPart> parts;
    … …  
    10584    private Vector<Node> nodes;
    10685
    107 
    108     private static double addMetersToLat(LatLon latLon, double south)
    109     {
     86    private static double addMetersToLat(LatLon latLon, double south) {
    11087        return latLon.lat() - south *(360./4e7);
    11188    }

  • applications/editors/josm/plugins/indoor_sweepline/src/indoor_sweepline/CorridorGeography.java

    r32479 r32601  
     1// License: GPL. For details, see LICENSE file.
    12package indoor_sweepline;
    23
    … …  
    89import org.openstreetmap.josm.data.osm.Way;
    910
     11public class CorridorGeography {
    1012
    11 public class CorridorGeography
    12 {
    13     public CorridorGeography(DataSet dataSet)
    14     {
     13    public CorridorGeography(DataSet dataSet) {
    1514        this.dataSet = dataSet;
    1615    }
    1716
    18 
    1917    private static final double MIN_LENGTH = 10.;
    2018
    21 
    2219    private void setExtraElements(CorridorPart.ReachableSide side, LatLon from, LatLon to,
    23             boolean extraWayUp, double minLength)
    24     {
     20            boolean extraWayUp, double minLength) {
    2521        LatLon middleCoor = new LatLon((from.lat() + to.lat())/2.,
    2622                (from.lon() + to.lon())/2.);
    27         if (middleNode == null)
    28         {
     23        if (middleNode == null) {
    2924            middleNode = new Node(middleCoor);
    3025            dataSet.addPrimitive(middleNode);
    31         }
    32         else
     26        } else
    3327            middleNode.setCoor(middleCoor);
    3428
    3529        LatLon start = from;
    36         if (side == CorridorPart.ReachableSide.LEFT)
    37         {
     30        if (side == CorridorPart.ReachableSide.LEFT) {
    3831            if (middleCoor.lat() < start.lat())
    3932                start = to;
    40         }
    41         else if (side == CorridorPart.ReachableSide.RIGHT)
    42         {
     33        } else if (side == CorridorPart.ReachableSide.RIGHT) {
    4334            if (start.lat() < middleCoor.lat())
    4435                start = to;
    45         }
    46         else if (side == CorridorPart.ReachableSide.FRONT)
    47         {
     36        } else if (side == CorridorPart.ReachableSide.FRONT) {
    4837            if (start.lon() < middleCoor.lon())
    4938                start = to;
    50         }
    51         else if (side == CorridorPart.ReachableSide.BACK)
    52         {
     39        } else if (side == CorridorPart.ReachableSide.BACK) {
    5340            if (middleCoor.lon() < start.lon())
    5441                start = to;
    … …  
    6148        LatLon detachedCoor = new LatLon(middleCoor.lat() + (start.lon() - middleCoor.lon()) * scale * lengthFactor,
    6249                middleCoor.lon() - (start.lat() - middleCoor.lat()) / scale * lengthFactor);
    63         if (detachedNode == null)
    64         {
     50        if (detachedNode == null) {
    6551            detachedNode = new Node(detachedCoor);
    6652            dataSet.addPrimitive(detachedNode);
    67         }
    68         else
     53        } else
    6954            detachedNode.setCoor(detachedCoor);
    7055
    7156        Vector<Node> extraWayNodes = new Vector<>();
    72         if (extraWayUp)
    73         {
     57        if (extraWayUp) {
    7458            extraWayNodes.add(middleNode);
    7559            extraWayNodes.add(detachedNode);
    76         }
    77         else
    78         {
     60        } else {
    7961            extraWayNodes.add(detachedNode);
    8062            extraWayNodes.add(middleNode);
    8163        }
    82         if (extraWay == null)
    83         {
     64        if (extraWay == null) {
    8465            extraWay = new Way();
    8566            extraWay.setNodes(extraWayNodes);
    8667            dataSet.addPrimitive(extraWay);
    87         }
    88         else
     68        } else
    8969            extraWay.setNodes(extraWayNodes);
    9070    }
    9171
    92 
    9372    public void appendNodes(CorridorPart.Type type, CorridorPart.ReachableSide side, String level,
    94             LatLon from, LatLon to, ModelGeography target)
    95     {
    96         if (type == CorridorPart.Type.STAIRS_UP || type == CorridorPart.Type.STAIRS_DOWN)
    97         {
     73            LatLon from, LatLon to, ModelGeography target) {
     74        if (type == CorridorPart.Type.STAIRS_UP || type == CorridorPart.Type.STAIRS_DOWN) {
    9875            setExtraElements(side, from, to, type == CorridorPart.Type.STAIRS_UP, MIN_LENGTH);
    9976            target.appendNode(middleNode);
    … …  
    10582            extraWay.put("incline", "up");
    10683            extraWay.put("level", level);
    107         }
    108         else if (type == CorridorPart.Type.ESCALATOR_UP_LEAVING
     84        } else if (type == CorridorPart.Type.ESCALATOR_UP_LEAVING
    10985                || type == CorridorPart.Type.ESCALATOR_UP_ARRIVING
    11086                || type == CorridorPart.Type.ESCALATOR_UP_BIDIRECTIONAL
    11187                || type == CorridorPart.Type.ESCALATOR_DOWN_LEAVING
    11288                || type == CorridorPart.Type.ESCALATOR_DOWN_ARRIVING
    113                 || type == CorridorPart.Type.ESCALATOR_DOWN_BIDIRECTIONAL)
    114         {
     89                || type == CorridorPart.Type.ESCALATOR_DOWN_BIDIRECTIONAL) {
    11590            setExtraElements(side, from, to,
    11691                    type == CorridorPart.Type.ESCALATOR_UP_LEAVING
    … …  
    133108                extraWay.put("conveying", "reversible");
    134109            extraWay.put("level", level);
    135         }
    136         else if (type == CorridorPart.Type.ELEVATOR)
    137         {
     110        } else if (type == CorridorPart.Type.ELEVATOR) {
    138111            setExtraElements(side, from, to, true, 0.);
    139112            target.appendNode(middleNode);
    … …  
    145118            extraWay.put("highway", "footway");
    146119            extraWay.put("level", level);
    147         }
    148         else
    149         {
    150             if (extraWay != null)
    151             {
     120        } else {
     121            if (extraWay != null) {
    152122                extraWay.setDeleted(true);
    153123                extraWay = null;
    154124            }
    155             if (middleNode != null)
    156             {
     125            if (middleNode != null) {
    157126                middleNode.setDeleted(true);
    158127                middleNode = null;
    159128            }
    160             if (detachedNode != null)
    161             {
     129            if (detachedNode != null) {
    162130                detachedNode.setDeleted(true);
    163131                detachedNode = null;
    … …  
    166134    }
    167135
    168 
    169136    private DataSet dataSet;
    170137    private Node middleNode;

  • applications/editors/josm/plugins/indoor_sweepline/src/indoor_sweepline/CorridorPart.java

    r32479 r32601  
     1// License: GPL. For details, see LICENSE file.
    12package indoor_sweepline;
    23
    3 public class CorridorPart
    4 {
    5     public enum Type
    6     {
    7         VOID,
    8         PASSAGE,
    9         WALL,
    10         STAIRS_UP,
    11         STAIRS_DOWN,
    12         ESCALATOR_UP_LEAVING,
    13         ESCALATOR_UP_ARRIVING,
    14         ESCALATOR_UP_BIDIRECTIONAL,
    15         ESCALATOR_DOWN_LEAVING,
    16         ESCALATOR_DOWN_ARRIVING,
    17         ESCALATOR_DOWN_BIDIRECTIONAL,
    18         ELEVATOR
     4public class CorridorPart {
     5
     6    public enum Type {
     7        VOID,
     8        PASSAGE,
     9        WALL,
     10        STAIRS_UP,
     11        STAIRS_DOWN,
     12        ESCALATOR_UP_LEAVING,
     13        ESCALATOR_UP_ARRIVING,
     14        ESCALATOR_UP_BIDIRECTIONAL,
     15        ESCALATOR_DOWN_LEAVING,
     16        ESCALATOR_DOWN_ARRIVING,
     17        ESCALATOR_DOWN_BIDIRECTIONAL,
     18        ELEVATOR
    1919    }
    20    
    2120
    22     public enum ReachableSide
    23     {
    24         ALL,
    25         FRONT,
    26         BACK,
    27         LEFT,
    28         RIGHT
     21    public enum ReachableSide {
     22        ALL,
     23        FRONT,
     24        BACK,
     25        LEFT,
     26        RIGHT
    2927    }
    30    
    3128
    32     public CorridorPart(double width, Type type, ReachableSide side)
    33     {
    34         this.width = width;
    35         this.type = type;
    36         this.side = side;
     29    public CorridorPart(double width, Type type, ReachableSide side) {
     30        this.width = width;
     31        this.type = type;
     32        this.side = side;
    3733    }
    38    
    39    
    40     public boolean isObstacle(ReachableSide beamSide)
    41     {
    42         if (type == Type.VOID)
    43             return false;
    44         if (type == Type.PASSAGE)
    45             return (beamSide != ReachableSide.ALL);
    46         return true;
     34
     35    public boolean isObstacle(ReachableSide beamSide) {
     36        if (type == Type.VOID)
     37            return false;
     38        if (type == Type.PASSAGE)
     39            return (beamSide != ReachableSide.ALL);
     40        return true;
    4741    }
    48    
    49    
    50     public Type getType()
    51     {
    52         return type;
     42
     43    public Type getType() {
     44        return type;
    5345    }
    54    
    55     public void setType(Type type, ReachableSide beamSide)
    56     {
    57         this.type = type;
    58         adjustSideType(beamSide);
     46
     47    public void setType(Type type, ReachableSide beamSide) {
     48        this.type = type;
     49        adjustSideType(beamSide);
    5950    }
    60    
    61    
    62     public ReachableSide getSide()
    63     {
    64         return side;
     51
     52    public ReachableSide getSide() {
     53        return side;
    6554    }
    66    
    67     public void setSide(ReachableSide side, ReachableSide beamSide)
    68     {
    69         this.side = side;
    70         adjustSideType(beamSide);
     55
     56    public void setSide(ReachableSide side, ReachableSide beamSide) {
     57        this.side = side;
     58        adjustSideType(beamSide);
    7159    }
    72    
    7360
    7461    public double width;
    7562    private Type type;
    7663    private ReachableSide side;
    77    
    78    
    79     private void adjustSideType(ReachableSide beamSide)
    80     {
    81         if (type == Type.PASSAGE || type == Type.VOID)
    82             side = ReachableSide.ALL;
    83         else if (side == ReachableSide.ALL)
    84         {
    85             if (beamSide == ReachableSide.RIGHT)
    86                 side = ReachableSide.RIGHT;
    87             else
    88                 side = ReachableSide.LEFT;
    89         }
     64
     65    private void adjustSideType(ReachableSide beamSide) {
     66        if (type == Type.PASSAGE || type == Type.VOID)
     67            side = ReachableSide.ALL;
     68        else if (side == ReachableSide.ALL) {
     69            if (beamSide == ReachableSide.RIGHT)
     70                side = ReachableSide.RIGHT;
     71            else
     72                side = ReachableSide.LEFT;
     73        }
    9074    }
    9175}

  • applications/editors/josm/plugins/indoor_sweepline/src/indoor_sweepline/IndoorSweepline.java

    r32479 r32601  
     1// License: GPL. For details, see LICENSE file.
    12package indoor_sweepline;
    23
    … …  
    89import org.openstreetmap.josm.plugins.PluginInformation;
    910
    10 public class IndoorSweepline extends Plugin
    11 {
     11public class IndoorSweepline extends Plugin {
    1212    /**
    13       * Will be invoked by JOSM to bootstrap the plugin
    14       *
    15       * @param info  information about the plugin and its local installation   
    16       */
    17     public IndoorSweepline(PluginInformation info)
    18     {
    19         super(info);
    20         refreshMenu();
     13     * Will be invoked by JOSM to bootstrap the plugin
     14     *
     15     * @param info  information about the plugin and its local installation
     16     */
     17    public IndoorSweepline(PluginInformation info) {
     18        super(info);
     19        refreshMenu();
    2120    }
    2221
    23     public static void refreshMenu()
    24     {
     22    public static void refreshMenu() {
    2523        JMenu menu = Main.main.menu.moreToolsMenu;
    2624        if (menu.isVisible())
    27             menu.addSeparator();
    28         else
    29             menu.setVisible(true);
     25            menu.addSeparator();
     26        else
     27            menu.setVisible(true);
    3028        menu.add(new JMenuItem(new IndoorSweeplineWizardAction()));
    3129    }

  • applications/editors/josm/plugins/indoor_sweepline/src/indoor_sweepline/IndoorSweeplineController.java

    r32479 r32601  
     1// License: GPL. For details, see LICENSE file.
    12package indoor_sweepline;
    23
    … …  
    1314import org.openstreetmap.josm.gui.layer.OsmDataLayer;
    1415
     16public class IndoorSweeplineController implements LayerChangeListener {
    1517
    16 public class IndoorSweeplineController implements LayerChangeListener
    17 {
    18     public IndoorSweeplineController(OsmDataLayer activeLayer, LatLon center)
    19     {
     18    public IndoorSweeplineController(OsmDataLayer activeLayer, LatLon center) {
    2019        Main.getLayerManager().addLayerChangeListener(this);
    2120        layer = activeLayer;
    … …  
    2524    }
    2625
    27 
    28     public IndoorSweeplineWizardDialog view()
    29     {
     26    public IndoorSweeplineWizardDialog view() {
    3027        return dialog;
    3128    }
    3229
    3330    @Override
    34     public void layerOrderChanged(LayerOrderChangeEvent e)
    35     {
     31    public void layerOrderChanged(LayerOrderChangeEvent e) {
    3632    }
    3733
    3834    @Override
    39     public void layerAdded(LayerAddEvent e)
    40     {
     35    public void layerAdded(LayerAddEvent e) {
    4136    }
    4237
    4338    @Override
    44     public void layerRemoving(LayerRemoveEvent e)
    45     {
     39    public void layerRemoving(LayerRemoveEvent e) {
    4640        if (e.getRemovedLayer() == layer)
    4741            dialog.setVisible(false);
    4842    }
    4943
    50     public int leftRightCount()
    51     {
     44    public int leftRightCount() {
    5245        return model.leftRightCount();
    5346    }
    5447
    55     public void addRightStructure()
    56     {
     48    public void addRightStructure() {
    5749        if (model.leftRightCount() % 2 == 0)
    5850            model.addBeam();
    … …  
    6153    }
    6254
    63     public DefaultComboBoxModel<String> structures()
    64     {
     55    public DefaultComboBoxModel<String> structures() {
    6556        return model.structures();
    6657    }
    6758
    68     public double getStripWidth(int index)
    69     {
     59    public double getStripWidth(int index) {
    7060        return model.getStripWidth(index);
    7161    }
    7262
    73     public void setStripWidth(int index, double value)
    74     {
     63    public void setStripWidth(int index, double value) {
    7564        model.setStripWidth(index, value);
    7665    }
    7766
    78     public double getBeamOffset(int index)
    79     {
     67    public double getBeamOffset(int index) {
    8068        return model.getBeamOffset(index);
    8169    }
    8270
    83     public void setBeamOffset(int index, double beamOffset)
    84     {
     71    public void setBeamOffset(int index, double beamOffset) {
    8572        model.setBeamOffset(index, beamOffset);
    8673    }
    8774
    88     public List<CorridorPart> getBeamParts(int index)
    89     {
     75    public List<CorridorPart> getBeamParts(int index) {
    9076        return model.getBeamParts(index);
    9177    }
    9278
    93     public void addCorridorPart(int beamIndex, boolean append, double value)
    94     {
     79    public void addCorridorPart(int beamIndex, boolean append, double value) {
    9580        model.addCorridorPart(beamIndex, append, value);
    9681    }
    9782
    98     public void setCorridorPartWidth(int beamIndex, int partIndex, double value)
    99     {
     83    public void setCorridorPartWidth(int beamIndex, int partIndex, double value) {
    10084        model.setCorridorPartWidth(beamIndex, partIndex, value);
    10185    }
    10286
    103     public void setCorridorPartType(int beamIndex, int partIndex, CorridorPart.Type type)
    104     {
     87    public void setCorridorPartType(int beamIndex, int partIndex, CorridorPart.Type type) {
    10588        model.setCorridorPartType(beamIndex, partIndex, type);
    10689    }
    10790
    108     public void setCorridorPartSide(int beamIndex, int partIndex, CorridorPart.ReachableSide side)
    109     {
     91    public void setCorridorPartSide(int beamIndex, int partIndex, CorridorPart.ReachableSide side) {
    11092        model.setCorridorPartSide(beamIndex, partIndex, side);
    11193    }
    11294
    113     public Strip getStrip(int beamIndex)
    114     {
     95    public Strip getStrip(int beamIndex) {
    11596        return model.getStrip(beamIndex);
    11697    }
    11798
    118     public IndoorSweeplineModel.Type getType()
    119     {
     99    public IndoorSweeplineModel.Type getType() {
    120100        return model.getType();
    121101    }
    122102
    123     public void setType(IndoorSweeplineModel.Type type)
    124     {
     103    public void setType(IndoorSweeplineModel.Type type) {
    125104        model.setType(type);
    126105    }
    127106
    128     public String getLevel()
    129     {
     107    public String getLevel() {
    130108        return model.getLevel();
    131109    }
    132110
    133     public void setLevel(String level)
    134     {
     111    public void setLevel(String level) {
    135112        model.setLevel(level);
    136113    }

  • applications/editors/josm/plugins/indoor_sweepline/src/indoor_sweepline/IndoorSweeplineModel.java

    r32479 r32601  
     1// License: GPL. For details, see LICENSE file.
    12package indoor_sweepline;
    23
    … …  
    910import org.openstreetmap.josm.data.coor.LatLon;
    1011import org.openstreetmap.josm.gui.layer.OsmDataLayer;
    11 
    1212
    1313/* TODO:
    … …  
    1515- keyboard shortcuts
    1616 */
    17 
    18 
    19 public class IndoorSweeplineModel
    20 {
    21     public enum Type
    22     {
     17public class IndoorSweeplineModel {
     18    public enum Type {
    2319        CORRIDOR,
    2420        PLATFORM
    25     };
    26 
    27 
    28     public IndoorSweeplineModel(OsmDataLayer activeLayer, LatLon center)
    29     {
     21    }
     22
     23    public IndoorSweeplineModel(OsmDataLayer activeLayer, LatLon center) {
    3024        target = new ModelGeography(activeLayer.data, center);
    3125
    … …  
    4135    }
    4236
    43 
    4437    private ModelGeography target;
    4538
    46 
    47     public void addBeam()
    48     {
     39    public void addBeam() {
    4940        CorridorPart.ReachableSide side = CorridorPart.ReachableSide.LEFT;
    5041        if (beams.size() == 0)
    … …  
    5243
    5344        /*double width = 10.;
    54         if (beams.size() > 0)
    55         {
    56             width = 0;
    57             for (CorridorPart part : beams.elementAt(beams.size() - 1).getBeamParts())
    58                 width += part.width;
    59         }
    60 
    61         double offset = 0;
    62         for (int i = 0; i < strips.size(); ++i)
    63             offset += strips.elementAt(i).width;*/
    64 
    65         if (strips.size() == 0)
    66         {
     45        if (beams.size() > 0) {
     46            width = 0;
     47            for (CorridorPart part : beams.elementAt(beams.size() - 1).getBeamParts())
     48                width += part.width;
     49        }
     50
     51        double offset = 0;
     52        for (int i = 0; i < strips.size(); ++i)
     53            offset += strips.elementAt(i).width;*/
     54
     55        if (strips.size() == 0) {
    6756            Vector<Double> blueprint = new Vector<>();
    6857            blueprint.addElement(0.);
    6958            blueprint.addElement(10.);
    7059            beams.add(new Beam(blueprint, 0., side));
    71         }
    72         else
     60        } else
    7361            beams.add(new Beam(strips.elementAt(strips.size()-1).lhs,
    7462                    beams.elementAt(beams.size()-1).getBeamOffset(), side));
    … …  
    8068    }
    8169
    82 
    83     public void addStrip()
    84     {
     70    public void addStrip() {
    8571        strips.add(new Strip(target.getDataSet()));
    86         if (beams.size() > 1)
    87         {
     72        if (beams.size() > 1) {
    8873            beams.elementAt(beams.size()-1).setDefaultSide(CorridorPart.ReachableSide.ALL);
    8974            strips.elementAt(strips.size()-2).rhs = beams.elementAt(strips.size()-1).leftHandSideStrips();
    … …  
    9479    }
    9580
    96 
    97     public int leftRightCount()
    98     {
     81    public int leftRightCount() {
    9982        return beams.size() + strips.size();
    10083    }
    10184
    102 
    103     public DefaultComboBoxModel<String> structures()
    104     {
     85    public DefaultComboBoxModel<String> structures() {
    10586        structureBox.removeAllElements();
    10687        double offset = 0;
    107         for (int i = 0; i < strips.size(); ++i)
    108         {
     88        for (int i = 0; i < strips.size(); ++i) {
    10989            if (i < beams.size())
    11090                structureBox.addElement(Double.toString(offset));
    … …  
    11999    }
    120100
    121 
    122     public Strip getStrip(int index)
    123     {
     101    public Strip getStrip(int index) {
    124102        return strips.elementAt(index / 2);
    125103    }
    126104
    127 
    128     public double getStripWidth(int index)
    129     {
     105    public double getStripWidth(int index) {
    130106        return strips.elementAt(index / 2).width;
    131107    }
    132108
    133 
    134     public void setStripWidth(int index, double value)
    135     {
     109    public void setStripWidth(int index, double value) {
    136110        strips.elementAt(index / 2).width = value;
    137 
    138         updateOsmModel();
    139     }
    140 
    141 
    142     public double getBeamOffset(int index)
    143     {
     111        updateOsmModel();
     112    }
     113
     114    public double getBeamOffset(int index) {
    144115        return beams.elementAt(index / 2).getBeamOffset();
    145116    }
    146117
    147     public void setBeamOffset(int index, double beamOffset)
    148     {
     118    public void setBeamOffset(int index, double beamOffset) {
    149119        beams.elementAt(index / 2).setBeamOffset(beamOffset);
    150120        updateOsmModel();
    151121    }
    152122
    153 
    154     public List<CorridorPart> getBeamParts(int index)
    155     {
     123    public List<CorridorPart> getBeamParts(int index) {
    156124        return beams.elementAt(index / 2).getBeamParts();
    157125    }
    158126
    159 
    160     public void addCorridorPart(int beamIndex, boolean append, double value)
    161     {
     127    public void addCorridorPart(int beamIndex, boolean append, double value) {
    162128        beams.elementAt(beamIndex / 2).addCorridorPart(append, value);
    163129        if (beamIndex / 2 > 0)
    … …  
    169135    }
    170136
    171 
    172     public void setCorridorPartWidth(int beamIndex, int partIndex, double value)
    173     {
     137    public void setCorridorPartWidth(int beamIndex, int partIndex, double value) {
    174138        beams.elementAt(beamIndex / 2).setCorridorPartWidth(partIndex, value);
    175139        if (beamIndex / 2 > 0)
    … …  
    181145    }
    182146
    183 
    184     public void setCorridorPartType(int beamIndex, int partIndex, CorridorPart.Type type)
    185     {
    186         if (beamIndex % 2 == 0)
    187         {
     147    public void setCorridorPartType(int beamIndex, int partIndex, CorridorPart.Type type) {
     148        if (beamIndex % 2 == 0) {
    188149            beams.elementAt(beamIndex / 2).setCorridorPartType(partIndex, type);
    189150            if (beamIndex / 2 > 0)
    … …  
    191152            if (beamIndex / 2 < strips.size())
    192153                strips.elementAt(beamIndex / 2).lhs = beams.elementAt(beamIndex / 2).rightHandSideStrips();
    193         }
    194         else
    195         {
     154        } else {
    196155            if (type != CorridorPart.Type.PASSAGE && type != CorridorPart.Type.VOID)
    197156                strips.elementAt(beamIndex / 2).setCorridorPartType(partIndex, type);
    … …  
    201160    }
    202161
    203 
    204     public void setCorridorPartSide(int beamIndex, int partIndex, CorridorPart.ReachableSide side)
    205     {
     162    public void setCorridorPartSide(int beamIndex, int partIndex, CorridorPart.ReachableSide side) {
    206163        beams.elementAt(beamIndex / 2).setCorridorPartSide(partIndex, side);
    207164        if (beamIndex / 2 > 0)
    … …  
    213170    }
    214171
    215 
    216     public Type getType()
    217     {
     172    public Type getType() {
    218173        return type;
    219174    }
    220175
    221     public void setType(Type type)
    222     {
     176    public void setType(Type type) {
    223177        this.type = type;
    224178        updateOsmModel();
    225179    }
    226180
    227 
    228     public String getLevel()
    229     {
     181    public String getLevel() {
    230182        return level;
    231183    }
    232184
    233     public void setLevel(String level)
    234     {
     185    public void setLevel(String level) {
    235186        this.level = level;
    236187        updateOsmModel();
    237188    }
    238 
    239189
    240190    private Vector<Beam> beams;
    … …  
    245195    DefaultComboBoxModel<String> structureBox;
    246196
    247 
    248     private void updateOsmModel()
    249     {
     197    private void updateOsmModel() {
    250198        distributeWays();
    251199        Main.map.mapView.repaint();
    252200    }
    253201
    254 
    255     public class SweepPolygonCursor
    256     {
    257         public SweepPolygonCursor(int stripIndex, int partIndex)
    258         {
     202    public class SweepPolygonCursor {
     203        public SweepPolygonCursor(int stripIndex, int partIndex) {
    259204            this.stripIndex = stripIndex;
    260205            this.partIndex = partIndex;
    261206        }
    262207
    263         public boolean equals(SweepPolygonCursor rhs)
    264         {
     208        public boolean equals(SweepPolygonCursor rhs) {
    265209            return rhs != null
    266210                    && stripIndex == rhs.stripIndex && partIndex == rhs.partIndex;
    … …  
    271215    }
    272216
    273 
    274     private void distributeWays()
    275     {
     217    private void distributeWays() {
    276218        target.startGeographyBuild(beams, strips);
    277219
    278220        Vector<Vector<Boolean>> stripRefs = new Vector<>();
    279         for (Strip strip : strips)
    280         {
     221        for (Strip strip : strips) {
    281222            Vector<Boolean> refs = new Vector<>();
    282223            if (strip.lhs.size() < strip.rhs.size())
    … …  
    288229
    289230        Boolean truePtr = new Boolean(true);
    290         for (int i = 0; i < stripRefs.size(); ++i)
    291         {
     231        for (int i = 0; i < stripRefs.size(); ++i) {
    292232            Vector<Boolean> refs = stripRefs.elementAt(i);
    293             for (int j = 0; j < refs.size(); ++j)
    294             {
    295                 if (refs.elementAt(j) == null)
    296                 {
     233            for (int j = 0; j < refs.size(); ++j) {
     234                if (refs.elementAt(j) == null) {
    297235                    target.startWay();
    298236
    … …  
    300238
    301239                    boolean toTheLeft = true;
    302                     while (stripRefs.elementAt(cursor.stripIndex).elementAt(cursor.partIndex) == null)
    303                     {
     240                    while (stripRefs.elementAt(cursor.stripIndex).elementAt(cursor.partIndex) == null) {
    304241                        stripRefs.elementAt(cursor.stripIndex).setElementAt(truePtr, cursor.partIndex);
    305                         if (toTheLeft && cursor.partIndex < strips.elementAt(cursor.stripIndex).lhs.size())
    306                         {
     242                        if (toTheLeft && cursor.partIndex < strips.elementAt(cursor.stripIndex).lhs.size()) {
    307243                            target.appendCorridorPart(
    308244                                    strips.elementAt(cursor.stripIndex).partAt(cursor.partIndex),
    … …  
    313249                            toTheLeft = beams.elementAt(cursor.stripIndex).appendNodes(
    314250                                    cursor, toTheLeft, target.beamAt(cursor.stripIndex), level);
    315                         }
    316                         else if (!toTheLeft && cursor.partIndex < strips.elementAt(cursor.stripIndex).rhs.size())
    317                         {
     251                        } else if (!toTheLeft && cursor.partIndex < strips.elementAt(cursor.stripIndex).rhs.size()) {
    318252                            target.appendCorridorPart(
    319253                                    strips.elementAt(cursor.stripIndex).partAt(cursor.partIndex),
    … …  
    324258                            toTheLeft = beams.elementAt(cursor.stripIndex + 1).appendNodes(
    325259                                    cursor, toTheLeft, target.beamAt(cursor.stripIndex + 1), level);
    326                         }
    327                         else
     260                        } else
    328261                            toTheLeft = appendUturn(cursor, toTheLeft);
    329262                    }
    … …  
    337270    }
    338271
    339 
    340     private boolean appendUturn(SweepPolygonCursor cursor, boolean toTheLeft)
    341     {
     272    private boolean appendUturn(SweepPolygonCursor cursor, boolean toTheLeft) {
    342273        Strip strip = strips.elementAt(cursor.stripIndex);
    343274        target.appendUturnNode(strip, cursor.partIndex, cursor.stripIndex,

  • applications/editors/josm/plugins/indoor_sweepline/src/indoor_sweepline/IndoorSweeplineWizardAction.java

    r32479 r32601  
     1// License: GPL. For details, see LICENSE file.
    12package indoor_sweepline;
    23
    … …  
    1920import org.openstreetmap.josm.gui.layer.OsmDataLayer;
    2021
     22public class IndoorSweeplineWizardAction extends JosmAction implements LayerChangeListener, ActiveLayerChangeListener {
    2123
    22 public class IndoorSweeplineWizardAction extends JosmAction implements LayerChangeListener, ActiveLayerChangeListener
    23 {
    24     public IndoorSweeplineWizardAction()
    25     {
     24    public IndoorSweeplineWizardAction() {
    2625        super(tr("Concourse wizard ..."), null,
    2726                tr("Opens up a wizard to create a concourse"), null, false);
    … …  
    3029
    3130    @Override
    32     public void actionPerformed(ActionEvent event)
    33     {
     31    public void actionPerformed(ActionEvent event) {
    3432        if (layer == null)
    3533            JOptionPane.showMessageDialog(JOptionPane.getFrameForComponent(Main.parent),
    … …  
    4543                    "No map view found.");
    4644        else
    47             new IndoorSweeplineController((OsmDataLayer)layer,
     45            new IndoorSweeplineController((OsmDataLayer) layer,
    4846                    Projections.inverseProject(Main.map.mapView.getCenter()));
    4947    }
    5048
    5149    @Override
    52     public void activeOrEditLayerChanged(ActiveLayerChangeEvent e)
    53     {
     50    public void activeOrEditLayerChanged(ActiveLayerChangeEvent e) {
    5451        layer = Main.getLayerManager().getActiveLayer();
    5552    }
    5653
    5754    @Override
    58     public void layerOrderChanged(LayerOrderChangeEvent e)
    59     {
     55    public void layerOrderChanged(LayerOrderChangeEvent e) {
    6056    }
    6157
    6258    @Override
    63     public void layerAdded(LayerAddEvent e)
    64     {
     59    public void layerAdded(LayerAddEvent e) {
    6560    }
    6661
    6762    @Override
    68     public void layerRemoving(LayerRemoveEvent e)
    69     {
     63    public void layerRemoving(LayerRemoveEvent e) {
    7064        if (layer == e.getRemovedLayer())
    7165            layer = null;

  • applications/editors/josm/plugins/indoor_sweepline/src/indoor_sweepline/IndoorSweeplineWizardDialog.java

    r32479 r32601  
     1// License: GPL. For details, see LICENSE file.
    12package indoor_sweepline;
    23
    … …  
    3334import org.openstreetmap.josm.Main;
    3435
    35 
    36 public class IndoorSweeplineWizardDialog extends JDialog
    37 {
    38     public IndoorSweeplineWizardDialog(IndoorSweeplineController controller)
    39     {
     36public class IndoorSweeplineWizardDialog extends JDialog {
     37
     38    public IndoorSweeplineWizardDialog(IndoorSweeplineController controller) {
    4039        super(JOptionPane.getFrameForComponent(Main.parent), "Indoor Sweepline Wizard", false);
    4140
    … …  
    6665    }
    6766
    68 
    6967    @Override
    70     public void setVisible(boolean visible)
    71     {
     68    public void setVisible(boolean visible) {
    7269        if (visible)
    7370            setLocationRelativeTo(JOptionPane.getFrameForComponent(Main.parent));
    … …  
    7572    }
    7673
    77 
    78     private void refresh()
    79     {
     74    private void refresh() {
    8075        inRefresh = true;
    8176
    … …  
    8681        structureBoxModel.setSelectedItem(structureBoxModel.getElementAt(beamIndex));
    8782
    88         try
    89         {
    90             if (beamIndex % 2 == 0)
    91             {
     83        try {
     84            if (beamIndex % 2 == 0) {
    9285                widthOffsetLabel.setText("Offset into background:");
    9386                stripWidth.setText(Double.toString(controller.getBeamOffset(beamIndex)));
    94             }
    95             else
    96             {
     87            } else {
    9788                widthOffsetLabel.setText("Strip width:");
    9889                stripWidth.setText(Double.toString(controller.getStripWidth(beamIndex)));
    9990            }
    100         }
    101         catch (IllegalStateException ex)
    102         {
    103         }
    104 
    105         try
    106         {
     91        } catch (IllegalStateException ex) {
     92            Main.trace(ex);
     93        }
     94
     95        try {
    10796            level.setText(controller.getLevel());
    108         }
    109         catch (IllegalStateException ex)
    110         {
     97        } catch (IllegalStateException ex) {
     98            Main.trace(ex);
    11199        }
    112100
    113101        typeBoxModel.setSelectedItem(structureTypeToString(controller.getType()));
    114102
    115 
    116103        structureTableModel.setRowCount(0);
    117         if (beamIndex % 2 == 0)
    118         {
     104        if (beamIndex % 2 == 0) {
    119105            Vector<Object> row = new Vector<>();
    120106            row.addElement("");
    … …  
    124110
    125111            List<CorridorPart> parts = controller.getBeamParts(beamIndex);
    126             for (CorridorPart part : parts)
    127             {
     112            for (CorridorPart part : parts) {
    128113                row = new Vector<>();
    129114                row.addElement(Double.toString(part.width));
    … …  
    138123            structureTableModel.addRow(row);
    139124            structureTableModel.isBeam = true;
    140         }
    141         else
    142         {
     125        } else {
    143126            Strip strip = controller.getStrip(beamIndex);
    144             for (int i = 0; i < strip.lhs.size() || i < strip.rhs.size(); ++i)
    145             {
     127            for (int i = 0; i < strip.lhs.size() || i < strip.rhs.size(); ++i) {
    146128                Vector<Object> row = new Vector<>();
    147129                String position = i < strip.lhs.size() ? strip.lhs.elementAt(i).toString() : "X";
    … …  
    160142    }
    161143
    162 
    163     private String corridorPartTypeToString(CorridorPart.Type type)
    164     {
     144    private String corridorPartTypeToString(CorridorPart.Type type) {
    165145        if (type == CorridorPart.Type.VOID)
    166146            return "void";
    … …  
    190170    }
    191171
    192 
    193     private CorridorPart.Type parseCorridorPartType(String val)
    194     {
     172    private CorridorPart.Type parseCorridorPartType(String val) {
    195173        if (val == "void")
    196174            return CorridorPart.Type.VOID;
    … …  
    220198    }
    221199
    222 
    223     private String corridorPartSideToString(CorridorPart.ReachableSide side)
    224     {
     200    private String corridorPartSideToString(CorridorPart.ReachableSide side) {
    225201        if (side == CorridorPart.ReachableSide.ALL)
    226202            return "all";
    … …  
    236212    }
    237213
    238 
    239     private CorridorPart.ReachableSide parseCorridorPartSide(String val)
    240     {
     214    private CorridorPart.ReachableSide parseCorridorPartSide(String val) {
    241215        if (val == "all")
    242216            return CorridorPart.ReachableSide.ALL;
    … …  
    252226    }
    253227
    254 
    255     private String structureTypeToString(IndoorSweeplineModel.Type type)
    256     {
     228    private String structureTypeToString(IndoorSweeplineModel.Type type) {
    257229        if (type == IndoorSweeplineModel.Type.CORRIDOR)
    258230            return "corridor";
    … …  
    262234    }
    263235
    264 
    265     private JComboBox<String> structureBox()
    266     {
     236    private JComboBox<String> structureBox() {
    267237        JComboBox<String> structureBox = new JComboBox<>(controller.structures());
    268238        structureBox.addActionListener(new StructureBoxListener());
    269239        return structureBox;
    270240    }
    271 
    272241
    273242    private IndoorSweeplineController controller;
    … …  
    279248    boolean inRefresh;
    280249
    281 
    282     private JComboBox<String> typeBox()
    283     {
    284         if (typeBoxModel == null)
    285         {
     250    private JComboBox<String> typeBox() {
     251        if (typeBoxModel == null) {
    286252            typeBoxModel = new DefaultComboBoxModel<>();
    287253            typeBoxModel.addElement("corridor");
    … …  
    295261    private DefaultComboBoxModel<String> typeBoxModel;
    296262
    297 
    298     private class TypeBoxListener implements ActionListener
    299     {
    300         @Override
    301         public void actionPerformed(ActionEvent e)
    302         {
     263    private class TypeBoxListener implements ActionListener {
     264        @Override
     265        public void actionPerformed(ActionEvent e) {
    303266            if (inRefresh)
    304267                return;
    305268
    306269            @SuppressWarnings("unchecked")
    307             String entry = (String)((JComboBox<String>)e.getSource()).getSelectedItem();
     270            String entry = (String) ((JComboBox<String>) e.getSource()).getSelectedItem();
    308271            if (entry == "corridor")
    309272                controller.setType(IndoorSweeplineModel.Type.CORRIDOR);
    … …  
    315278    }
    316279
    317 
    318     private class PrevAction extends AbstractAction
    319     {
    320         public PrevAction()
    321         {
     280    private class PrevAction extends AbstractAction {
     281        PrevAction() {
    322282            super("Prev");
    323283        }
    324284
    325285        @Override
    326         public void actionPerformed(ActionEvent e)
    327         {
     286        public void actionPerformed(ActionEvent e) {
    328287            if (inRefresh)
    329288                return;
    … …  
    335294    }
    336295
    337 
    338     private class NextAction extends AbstractAction
    339     {
    340         public NextAction()
    341         {
     296    private class NextAction extends AbstractAction {
     297        NextAction() {
    342298            super("Next");
    343299        }
    344300
    345301        @Override
    346         public void actionPerformed(ActionEvent e)
    347         {
     302        public void actionPerformed(ActionEvent e) {
    348303            if (inRefresh)
    349304                return;
    … …  
    356311    }
    357312
    358 
    359     private class StructureBoxListener implements ActionListener
    360     {
    361         @Override
    362         public void actionPerformed(ActionEvent e)
    363         {
     313    private class StructureBoxListener implements ActionListener {
     314        @Override
     315        public void actionPerformed(ActionEvent e) {
    364316            if (inRefresh)
    365317                return;
    366318
    367319            @SuppressWarnings("unchecked")
    368             String entry = (String)((JComboBox<String>)e.getSource()).getSelectedItem();
     320            String entry = (String) ((JComboBox<String>) e.getSource()).getSelectedItem();
    369321            DefaultComboBoxModel<String> structureBoxModel = controller.structures();
    370             for (int i = 0; i < structureBoxModel.getSize(); ++i)
    371             {
     322            for (int i = 0; i < structureBoxModel.getSize(); ++i) {
    372323                if (structureBoxModel.getElementAt(i).equals(entry))
    373324                    beamIndex = i;
    … …  
    377328    }
    378329
    379 
    380330    private JLabel widthOffsetLabel;
    381331
    382     private JLabel makeWidthLabel()
    383     {
     332    private JLabel makeWidthLabel() {
    384333        widthOffsetLabel = new JLabel(tr("Offset into background:"));
    385334        return widthOffsetLabel;
    386335    }
    387336
    388 
    389337    private JTextField stripWidth;
    390338
    391     private JTextField makeWidthField()
    392     {
     339    private JTextField makeWidthField() {
    393340        stripWidth = new JTextField(5);
    394341        stripWidth.getDocument().addDocumentListener(new StripWidthListener());
    … …  
    396343    }
    397344
    398 
    399     private class StripWidthListener implements DocumentListener
    400     {
    401         @Override
    402         public void changedUpdate(DocumentEvent e)
    403         {
     345    private class StripWidthListener implements DocumentListener {
     346        @Override
     347        public void changedUpdate(DocumentEvent e) {
    404348            update(e);
    405349        }
    406350
    407351        @Override
    408         public void insertUpdate(DocumentEvent e)
    409         {
     352        public void insertUpdate(DocumentEvent e) {
    410353            update(e);
    411354        }
    412355
    413356        @Override
    414         public void removeUpdate(DocumentEvent e)
    415         {
     357        public void removeUpdate(DocumentEvent e) {
    416358            update(e);
    417359        }
    418360
    419 
    420         private void update(DocumentEvent e)
    421         {
    422             if (inRefresh)
    423                 return;
    424 
    425             try
    426             {
     361        private void update(DocumentEvent e) {
     362            if (inRefresh)
     363                return;
     364
     365            try {
    427366                if (beamIndex % 2 == 0)
    428367                    controller.setBeamOffset(beamIndex, Double.parseDouble(stripWidth.getText()));
    429368                else
    430369                    controller.setStripWidth(beamIndex, Double.parseDouble(stripWidth.getText()));
     370            } catch (NumberFormatException ex) {
     371                Main.trace(ex);
    431372            }
    432             catch (NumberFormatException ex)
    433             {
    434             }
    435 
    436             refresh();
    437         }
    438     }
    439 
     373
     374            refresh();
     375        }
     376    }
    440377
    441378    private JTextField level;
    442379
    443     private JTextField makeLevelField()
    444     {
     380    private JTextField makeLevelField() {
    445381        level = new JTextField(5);
    446382        level.getDocument().addDocumentListener(new LevelFieldListener());
    … …  
    448384    }
    449385
    450 
    451     private class LevelFieldListener implements DocumentListener
    452     {
    453         @Override
    454         public void changedUpdate(DocumentEvent e)
    455         {
     386    private class LevelFieldListener implements DocumentListener {
     387        @Override
     388        public void changedUpdate(DocumentEvent e) {
    456389            update(e);
    457390        }
    458391
    459392        @Override
    460         public void insertUpdate(DocumentEvent e)
    461         {
     393        public void insertUpdate(DocumentEvent e) {
    462394            update(e);
    463395        }
    464396
    465397        @Override
    466         public void removeUpdate(DocumentEvent e)
    467         {
     398        public void removeUpdate(DocumentEvent e) {
    468399            update(e);
    469400        }
    470401
    471 
    472         private void update(DocumentEvent e)
    473         {
     402        private void update(DocumentEvent e) {
    474403            if (inRefresh)
    475404                return;
    … …  
    481410    }
    482411
    483 
    484     private class StructureTableModel extends DefaultTableModel
    485     {
    486         @Override
    487         public boolean isCellEditable(int row, int column)
    488         {
     412    private class StructureTableModel extends DefaultTableModel {
     413        @Override
     414        public boolean isCellEditable(int row, int column) {
    489415            return isBeam || column == 1;
    490416        }
    … …  
    495421    private StructureTableModel structureTableModel;
    496422
    497     private JScrollPane makeStructureTable()
    498     {
     423    private JScrollPane makeStructureTable() {
    499424        structureTableModel = new StructureTableModel();
    500425        structureTableModel.addColumn("Width");
    … …  
    531456    }
    532457
    533     private class StructureTableListener implements TableModelListener
    534     {
    535         @Override
    536         public void tableChanged(TableModelEvent e)
    537         {
     458    private class StructureTableListener implements TableModelListener {
     459        @Override
     460        public void tableChanged(TableModelEvent e) {
    538461            if (inRefresh)
    539462                return;
    … …  
    541464            int column = e.getColumn();
    542465            int row = e.getFirstRow();
    543             if (column == 0 && beamIndex % 2 == 0)
    544             {
    545                 try
    546                 {
     466            if (column == 0 && beamIndex % 2 == 0) {
     467                try {
    547468                    if (row == 0 || row == structureTableModel.getRowCount() - 1)
    548469                        controller.addCorridorPart(beamIndex, row != 0,
    549                         Double.parseDouble(((TableModel)e.getSource()).getValueAt(row, column).toString()));
     470                        Double.parseDouble(((TableModel) e.getSource()).getValueAt(row, column).toString()));
    550471                    else
    551472                        controller.setCorridorPartWidth(beamIndex, row - 1,
    552                                 Double.parseDouble(((TableModel)e.getSource()).getValueAt(row, column).toString()));
     473                                Double.parseDouble(((TableModel) e.getSource()).getValueAt(row, column).toString()));
     474                } catch (NumberFormatException ex) {
     475                    Main.trace(ex);
    553476                }
    554                 catch (NumberFormatException ex)
    555                 {
    556                 }
    557             }
    558             else if (column == 1 && beamIndex % 2 == 0)
    559             {
     477            } else if (column == 1 && beamIndex % 2 == 0) {
    560478                if (row > 0 && row < structureTableModel.getRowCount() - 1)
    561479                    controller.setCorridorPartType(beamIndex, row - 1,
    562                             parseCorridorPartType(((TableModel)e.getSource()).getValueAt(row, column).toString()));
    563             }
    564             else if (column == 1 && beamIndex % 2 == 1)
    565             {
     480                            parseCorridorPartType(((TableModel) e.getSource()).getValueAt(row, column).toString()));
     481            } else if (column == 1 && beamIndex % 2 == 1) {
    566482                controller.setCorridorPartType(beamIndex, row,
    567                         parseCorridorPartType(((TableModel)e.getSource()).getValueAt(row, column).toString()));
    568             }
    569             else if (column == 2 && beamIndex % 2 == 0)
    570             {
     483                        parseCorridorPartType(((TableModel) e.getSource()).getValueAt(row, column).toString()));
     484            } else if (column == 2 && beamIndex % 2 == 0) {
    571485                if (row > 0 && row < structureTableModel.getRowCount() - 1)
    572486                    controller.setCorridorPartSide(beamIndex, row - 1,
    573                             parseCorridorPartSide(((TableModel)e.getSource()).getValueAt(row, column).toString()));
     487                            parseCorridorPartSide(((TableModel) e.getSource()).getValueAt(row, column).toString()));
    574488            }
    575489
    … …  
    578492    }
    579493
    580 
    581     private class GridbagPanel extends JPanel
    582     {
    583         public GridbagPanel()
    584         {
     494    private class GridbagPanel extends JPanel {
     495        GridbagPanel() {
    585496            gridbag = new GridBagLayout();
    586497            layoutCons = new GridBagConstraints();
    … …  
    588499        }
    589500
    590         public void add(Component comp, int gridx, int gridy, int gridwidth, int gridheight)
    591         {
     501        public void add(Component comp, int gridx, int gridy, int gridwidth, int gridheight) {
    592502            layoutCons.gridx = gridx;
    593503            layoutCons.gridy = gridy;

  • applications/editors/josm/plugins/indoor_sweepline/src/indoor_sweepline/ModelGeography.java

    r32479 r32601  
     1// License: GPL. For details, see LICENSE file.
    12package indoor_sweepline;
    23
    … …  
    1213import org.openstreetmap.josm.data.osm.Way;
    1314
    14 
    15 public class ModelGeography
    16 {
    17     public ModelGeography(DataSet dataSet, LatLon center)
    18     {
     15public class ModelGeography {
     16
     17    public ModelGeography(DataSet dataSet, LatLon center) {
    1918        beamsGeography = new Vector<>();
    2019
    … …  
    3231    }
    3332
    34 
    3533    private Vector<BeamGeography> beamsGeography;
    3634
    … …  
    4745    private Vector<RelationMember> members;
    4846
    49 
    50     public void appendNode(Node node)
    51     {
     47    public void appendNode(Node node) {
    5248        nodes.add(node);
    5349    }
    5450
    55 
    56     public DataSet getDataSet()
    57     {
     51    public DataSet getDataSet() {
    5852        return dataSet;
    5953    }
    6054
    61 
    62     public BeamGeography beamAt(int i)
    63     {
     55    public BeamGeography beamAt(int i) {
    6456        return beamsGeography.elementAt(i);
    6557    }
    6658
    67 
    68     public void startGeographyBuild(Vector<Beam> beams, Vector<Strip> strips)
    69     {
     59    public void startGeographyBuild(Vector<Beam> beams, Vector<Strip> strips) {
    7060        if (beamsGeography.size() < beams.size())
    7161            beamsGeography.setSize(beams.size());
    7262
    7363        double offset = 0;
    74         for (int i = 0; i < beams.size(); ++i)
    75         {
     64        for (int i = 0; i < beams.size(); ++i) {
    7665            if (beamsGeography.elementAt(i) == null)
    7766                beamsGeography.setElementAt(new BeamGeography(dataSet, this), i);
    … …  
    9180    }
    9281
    93 
    94     public void startWay()
    95     {
     82    public void startWay() {
    9683        nodes = new Vector<>();
    9784    }
    9885
    99 
    100     public void finishWay(Strip strip, int partIndex, boolean isOuter, String level)
    101     {
    102         if (nodes.size() > 0)
    103         {
     86    public void finishWay(Strip strip, int partIndex, boolean isOuter, String level) {
     87        if (nodes.size() > 0) {
    10488            CorridorPart part = strip.partAt(partIndex);
    10589            strip.geographyAt(partIndex).appendNodes(part.getType(), part.getSide(), level,
    … …  
    11296    }
    11397
    114 
    11598    public void appendCorridorPart(CorridorPart part, CorridorGeography partGeography, int beamIndex, int partIndex,
    116             String level)
    117     {
     99            String level) {
    118100        if (nodes.size() > 0)
    119101            partGeography.appendNodes(part.getType(), part.getSide(), level,
    … …  
    122104    }
    123105
    124 
    125106    public void appendUturnNode(Strip strip, int partIndex, int stripIndex, int beamNodeIndex, boolean toTheLeft,
    126             String level)
    127     {
     107            String level) {
    128108        if (toTheLeft)
    129109            assignCoor(addMeterOffset(beamsGeography.elementAt(stripIndex + 1).coorAt(beamNodeIndex),
    … …  
    133113                    0, strip.width / 2.));
    134114
    135         if (nodes.size() > 0)
    136         {
     115        if (nodes.size() > 0) {
    137116            CorridorPart part = strip.partAt(partIndex);
    138117            strip.geographyAt(partIndex).appendNodes(part.getType(), part.getSide(), level,
    … …  
    143122    }
    144123
    145 
    146     public void finishGeographyBuild(IndoorSweeplineModel.Type type, String level)
    147     {
    148         for (int i = nodePoolCount; i < nodePool.size(); ++i)
     124    public void finishGeographyBuild(IndoorSweeplineModel.Type type, String level) {
     125        for (int i = nodePoolCount; i < nodePool.size(); ++i) {
    149126            nodePool.elementAt(i).setDeleted(true);
     127        }
    150128        nodePool.setSize(nodePoolCount);
    151129
    152         for (int i = wayPoolCount; i < wayPool.size(); ++i)
     130        for (int i = wayPoolCount; i < wayPool.size(); ++i) {
    153131            wayPool.elementAt(i).setDeleted(true);
     132        }
    154133        wayPool.setSize(wayPoolCount);
    155134
    … …  
    157136    }
    158137
    159 
    160     private static LatLon addMeterOffset(LatLon latLon, double south, double east)
    161     {
     138    private static LatLon addMeterOffset(LatLon latLon, double south, double east) {
    162139        double scale = Math.cos(latLon.lat() * (Math.PI/180.));
    163140        return new LatLon(latLon.lat() - south *(360./4e7), latLon.lon() + east / scale *(360./4e7));
    164141    }
    165142
    166 
    167     private static double addMetersToLon(LatLon latLon, double east)
    168     {
     143    private static double addMetersToLon(LatLon latLon, double east) {
    169144        double scale = Math.cos(latLon.lat() * (Math.PI/180.));
    170145        return latLon.lon() + east / scale *(360./4e7);
    171146    }
    172147
    173 
    174     private void assignCoor(LatLon latLon)
    175     {
     148    private void assignCoor(LatLon latLon) {
    176149        if (nodePoolCount < nodePool.size())
    177150            nodePool.elementAt(nodePoolCount).setCoor(latLon);
    178         else
    179         {
     151        else {
    180152            Node node = new Node(latLon);
    181153            dataSet.addPrimitive(node);
    … …  
    184156    }
    185157
    186 
    187     private void assignNds(List<Node> nodes)
    188     {
     158    private void assignNds(List<Node> nodes) {
    189159        if (wayPoolCount < wayPool.size())
    190160            wayPool.elementAt(wayPoolCount).setNodes(nodes);
    191         else
    192         {
     161        else {
    193162            Way way = new Way();
    194163            way.setNodes(nodes);
    … …  
    198167    }
    199168
    200 
    201     private static void addPolygonTags(IndoorSweeplineModel.Type type, String level, OsmPrimitive obj)
    202     {
    203         if (type == IndoorSweeplineModel.Type.PLATFORM)
    204         {
     169    private static void addPolygonTags(IndoorSweeplineModel.Type type, String level, OsmPrimitive obj) {
     170        if (type == IndoorSweeplineModel.Type.PLATFORM) {
    205171            obj.put("railway", "platform");
    206172            obj.put("public_transport", "platform");
    207173            obj.put("area", "yes");
    208174            obj.put("level", level);
    209         }
    210         else
    211         {
     175        } else {
    212176            obj.put("highway", "pedestrian");
    213177            obj.put("indoor", "corridor");
    … …  
    217181    }
    218182
    219 
    220     private void adjustMultipolygonRelation(IndoorSweeplineModel.Type type, String level)
    221     {
    222         if (members.size() > 1)
    223         {
     183    private void adjustMultipolygonRelation(IndoorSweeplineModel.Type type, String level) {
     184        if (members.size() > 1) {
    224185            if (wayPool.size() > 0)
    225186                wayPool.elementAt(0).removeAll();
    226187
    227             if (multipolygon == null)
    228             {
     188            if (multipolygon == null) {
    229189                multipolygon = new Relation();
    230190                dataSet.addPrimitive(multipolygon);
    … …  
    236196
    237197            multipolygon.setMembers(members);
    238         }
    239         else
    240         {
    241             if (multipolygon != null)
    242             {
     198        } else {
     199            if (multipolygon != null) {
    243200                multipolygon.setDeleted(true);
    244201                multipolygon = null;
    245202            }
    246203
    247             if (wayPool.size() == 1)
    248             {
     204            if (wayPool.size() == 1) {
    249205                wayPool.elementAt(0).removeAll();
    250206                addPolygonTags(type, level, wayPool.elementAt(0));

  • applications/editors/josm/plugins/indoor_sweepline/src/indoor_sweepline/Strip.java

    r32479 r32601  
     1// License: GPL. For details, see LICENSE file.
    12package indoor_sweepline;
    2 
    33
    44import java.util.Vector;
    … …  
    66import org.openstreetmap.josm.data.osm.DataSet;
    77
     8public class Strip {
    89
    9 public class Strip
    10 {
    11     public Strip(DataSet dataSet)
    12     {
     10    public Strip(DataSet dataSet) {
    1311        width = 10.;
    1412        parts = new Vector<>();
    … …  
    2018    }
    2119
    22 
    23     public void setCorridorPartType(int partIndex, CorridorPart.Type type)
    24     {
    25         while (parts.size() <= partIndex)
    26         {
     20    public void setCorridorPartType(int partIndex, CorridorPart.Type type) {
     21        while (parts.size() <= partIndex) {
    2722            parts.add(new CorridorPart(0., CorridorPart.Type.WALL,
    2823                    parts.size() % 2 == 0 ? CorridorPart.ReachableSide.FRONT :
    … …  
    3328    }
    3429
    35 
    36     public CorridorPart partAt(int i)
    37     {
    38         while (parts.size() <= i)
    39         {
     30    public CorridorPart partAt(int i) {
     31        while (parts.size() <= i) {
    4032            parts.add(new CorridorPart(0., CorridorPart.Type.WALL,
    4133                    parts.size() % 2 == 0 ? CorridorPart.ReachableSide.FRONT :
    … …  
    4638    }
    4739
    48 
    49     public CorridorGeography geographyAt(int i)
    50     {
    51         while (parts.size() <= i)
    52         {
     40    public CorridorGeography geographyAt(int i) {
     41        while (parts.size() <= i) {
    5342            parts.add(new CorridorPart(0., CorridorPart.Type.WALL,
    5443                    parts.size() % 2 == 0 ? CorridorPart.ReachableSide.FRONT :
    … …  
    5847        return partsGeography.elementAt(i);
    5948    }
    60 
    6149
    6250    public double width;
Note: See TracChangeset for help on using the changeset viewer.