Changeset 5066 in josm for trunk


Ignore:
Timestamp:
2012-03-10T16:18:23+01:00 (8 years ago)
Author:
bastiK
Message:

Proj parameter refactoring (see #7495)

Location:
trunk/src/org/openstreetmap/josm/data/projection
Files:
2 added
19 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/org/openstreetmap/josm/data/projection/BelgianLambert1972.java

    r5022 r5066  
    77import org.openstreetmap.josm.data.projection.datum.SevenParameterDatum;
    88import org.openstreetmap.josm.data.projection.proj.LambertConformalConic;
     9import org.openstreetmap.josm.data.projection.proj.ProjParameters;
    910
    1011/**
    1112 * Belgian Lambert 72 projection as specified by the Belgian IGN
    1213 * in this document: http://www.ngi.be/Common/Lambert2008/Transformation_Geographic_Lambert_FR.pdf
    13  * @author Don-vip 
     14 * @author Don-vip
    1415 *
    1516 */
     
    1920        ellps = Ellipsoid.hayford;
    2021        // 7 parameters transformation: http://www.eye4software.com/resources/datum/4313/
    21         datum = new SevenParameterDatum("Belgium Datum 72", null, Ellipsoid.hayford, -99.06, 53.32, -112.49, 0.419, -0.830, 1.885, -1);
     22        datum = new SevenParameterDatum("Belgium Datum 72", null, ellps, -99.06, 53.32, -112.49, 0.419, -0.830, 1.885, -1);
    2223        x_0 =  150000.013;
    2324        y_0 = 5400088.438;
    2425        lon_0 = convertDegreeMinuteSecond(4, 22, 2.952);
    25         double lat_0 = 90.0;
    26         double lat_1 = 49 + convertMinuteSecond(50, 0.00204);
    27         double lat_2 = 51 + convertMinuteSecond(10, 0.00204);
    2826        proj = new LambertConformalConic();
    29         ((LambertConformalConic)proj).updateParameters2SP(ellps, lat_0, lat_1, lat_2);
     27        try {
     28            proj.initialize(new ProjParameters() {{
     29                ellps = BelgianLambert1972.this.ellps;
     30                lat_0 = 90.0;
     31                lat_1 = 49 + convertMinuteSecond(50, 0.00204);
     32                lat_2 = 51 + convertMinuteSecond(10, 0.00204);
     33            }});
     34        } catch (ProjectionConfigurationException e) {
     35            throw new RuntimeException(e);
     36        }
    3037    }
    31    
     38
    3239    @Override
    3340    public String getCacheDirectoryName() {
     
    4653        return 31370;
    4754    }
    48    
     55
    4956    @Override
    5057    public String toString() {
  • trunk/src/org/openstreetmap/josm/data/projection/BelgianLambert2008.java

    r5022 r5066  
    77import org.openstreetmap.josm.data.projection.datum.GRS80Datum;
    88import org.openstreetmap.josm.data.projection.proj.LambertConformalConic;
     9import org.openstreetmap.josm.data.projection.proj.ProjParameters;
    910
    1011/**
    1112 * Belgian Lambert 2008 projection as specified by the Belgian IGN
    1213 * in this document: http://www.ngi.be/Common/Lambert2008/Transformation_Geographic_Lambert_FR.pdf
    13  * @author Don-vip 
     14 * @author Don-vip
    1415 *
    1516 */
     
    2223        y_0 = 665262.0;
    2324        lon_0 = convertDegreeMinuteSecond(4, 21, 33.177);
    24         double lat_0 = convertDegreeMinuteSecond(50, 47, 52.134);
    25         double lat_1 = convertDegreeMinuteSecond(49, 50,  0);
    26         double lat_2 = convertDegreeMinuteSecond(51, 10,  0);
    2725        proj = new LambertConformalConic();
    28         ((LambertConformalConic)proj).updateParameters2SP(ellps, lat_0, lat_1, lat_2);
     26        try {
     27            proj.initialize(new ProjParameters() {{
     28                ellps = BelgianLambert2008.this.ellps;
     29                lat_0 = convertDegreeMinuteSecond(50, 47, 52.134);
     30                lat_1 = convertDegreeMinuteSecond(49, 50,  0);
     31                lat_2 = convertDegreeMinuteSecond(51, 10,  0);
     32            }});
     33        } catch (ProjectionConfigurationException e) {
     34            throw new RuntimeException(e);
     35        }
    2936    }
    30    
     37
    3138    @Override
    3239    public String getCacheDirectoryName() {
     
    4552        return 3812;
    4653    }
    47    
     54
    4855    @Override
    4956    public String toString() {
  • trunk/src/org/openstreetmap/josm/data/projection/Epsg3008.java

    r4285 r5066  
    77import org.openstreetmap.josm.data.coor.LatLon;
    88import org.openstreetmap.josm.data.projection.datum.GRS80Datum;
     9import org.openstreetmap.josm.data.projection.proj.ProjParameters;
    910import org.openstreetmap.josm.data.projection.proj.TransverseMercator;
    1011
     
    1920    public Epsg3008() {
    2021        ellps = Ellipsoid.GRS80;
    21         proj = new TransverseMercator(ellps);
     22        proj = new org.openstreetmap.josm.data.projection.proj.TransverseMercator();
     23        try {
     24            proj.initialize(new ProjParameters() {{ ellps = Epsg3008.this.ellps; }});
     25        } catch (ProjectionConfigurationException e) {
     26            throw new RuntimeException(e);
     27        }
    2228        datum = GRS80Datum.INSTANCE;
    2329        lon_0 = 13.5;
    2430        x_0 = 150000;
    2531    }
    26    
     32
    2733    @Override
    2834    public String toString() {
  • trunk/src/org/openstreetmap/josm/data/projection/GaussKrueger.java

    r4869 r5066  
    1717import org.openstreetmap.josm.data.Bounds;
    1818import org.openstreetmap.josm.data.coor.LatLon;
     19import org.openstreetmap.josm.data.projection.proj.ProjParameters;
    1920import org.openstreetmap.josm.data.projection.proj.TransverseMercator;
    2021import org.openstreetmap.josm.tools.GBC;
     
    6465        //        tr("Deutsches Hauptdreiecksnetz"), null, ellps,
    6566        //        598.1, 73.7, 418.2, 0.202, 0.045, -2.455, 6.70);
    66         proj = new TransverseMercator(ellps);
     67        proj = new TransverseMercator();
     68        try {
     69            proj.initialize(new ProjParameters() {{ ellps = GaussKrueger.this.ellps; }});
     70        } catch (ProjectionConfigurationException e) {
     71            throw new RuntimeException(e);
     72        }
    6773        x_0 = 1000000 * zone + 500000;
    6874        lon_0 = 3 * zone;
  • trunk/src/org/openstreetmap/josm/data/projection/Lambert.java

    r4288 r5066  
    1818import org.openstreetmap.josm.data.coor.LatLon;
    1919import org.openstreetmap.josm.data.projection.proj.LambertConformalConic;
     20import org.openstreetmap.josm.data.projection.proj.ProjParameters;
    2021import org.openstreetmap.josm.tools.GBC;
    2122import org.openstreetmap.josm.tools.ImageProvider;
     
    9697        updateParameters(DEFAULT_ZONE);
    9798    }
    98    
    99     private void updateParameters(int layoutZone) {
     99
     100    private void updateParameters(final int layoutZone) {
    100101        this.layoutZone = layoutZone;
    101102        ellps = Ellipsoid.clarke;
     
    107108            proj = new LambertConformalConic();
    108109        }
    109         ((LambertConformalConic)proj).updateParametersDirect(
    110                 Ellipsoid.clarke, n[layoutZone], c[layoutZone] / ellps.a, y_fs[layoutZone] / ellps.a);
    111     }
    112 
    113     @Override
     110        proj = new LambertConformalConic();
     111        try {
     112            proj.initialize(new ProjParameters() {{
     113                ellps = Lambert.this.ellps;
     114                lcc_n = n[layoutZone];
     115                lcc_F = c[layoutZone] / ellps.a;
     116                lcc_r0 = y_fs[layoutZone] / ellps.a;
     117            }});
     118        } catch (ProjectionConfigurationException e) {
     119            throw new RuntimeException(e);
     120        }
     121    }
     122
     123    @Override
    114124    public String toString() {
    115125        return tr("Lambert 4 Zones (France)");
  • trunk/src/org/openstreetmap/josm/data/projection/Lambert93.java

    r4781 r5066  
    77import org.openstreetmap.josm.data.projection.datum.GRS80Datum;
    88import org.openstreetmap.josm.data.projection.proj.LambertConformalConic;
     9import org.openstreetmap.josm.data.projection.proj.ProjParameters;
    910
    1011/**
    1112 * Lambert 93 projection as specified by the IGN
    1213 * in this document http://professionnels.ign.fr/DISPLAY/000/526/702/5267026/NTG_87.pdf
    13  * @author Don-vip 
     14 * @author Don-vip
    1415 *
    1516 */
     
    2223        y_0 = 6600000;
    2324        lon_0 = 3;
    24         double lat_0 = 46.50;
    25         double lat_1 = 44.00;
    26         double lat_2 = 49.00;
    2725        proj = new LambertConformalConic();
    28         ((LambertConformalConic)proj).updateParameters2SP(ellps, lat_0, lat_1, lat_2);
     26        try {
     27            proj.initialize(new ProjParameters() {{
     28                ellps = Lambert93.this.ellps;
     29                lat_0 = 46.50;
     30                lat_1 = 44.00;
     31                lat_2 = 49.00;
     32            }});
     33        } catch (ProjectionConfigurationException e) {
     34            throw new RuntimeException(e);
     35        }
    2936    }
    30    
     37
    3138    @Override
    3239    public String getCacheDirectoryName() {
     
    4552        return 2154;
    4653    }
    47    
     54
    4855    @Override
    4956    public String toString() {
  • trunk/src/org/openstreetmap/josm/data/projection/LambertCC9Zones.java

    r4382 r5066  
    1717import org.openstreetmap.josm.data.projection.datum.GRS80Datum;
    1818import org.openstreetmap.josm.data.projection.proj.LambertConformalConic;
     19import org.openstreetmap.josm.data.projection.proj.ProjParameters;
    1920import org.openstreetmap.josm.tools.GBC;
    2021import org.openstreetmap.josm.tools.ImageProvider;
     
    4950    }
    5051
    51     public void updateParameters(int layoutZone) {
     52    public void updateParameters(final int layoutZone) {
    5253        ellps = Ellipsoid.GRS80;
    5354        datum = GRS80Datum.INSTANCE;
     
    5657        y_0 = (layoutZone+1) * 1000000 + 200000;
    5758        lon_0 = 3;
    58         double lat_0 = 42 + layoutZone;
    59         double lat_1 = 41.25 + layoutZone;
    60         double lat_2 = 42.75 + layoutZone;
    6159        if (proj == null) {
    6260            proj = new LambertConformalConic();
    6361        }
    64         ((LambertConformalConic)proj).updateParameters2SP(ellps, lat_0, lat_1, lat_2);
     62        try {
     63            proj.initialize(new ProjParameters() {{
     64                ellps = LambertCC9Zones.this.ellps;
     65                lat_0 = 42.0 + layoutZone;
     66                lat_1 = 41.25 + layoutZone;
     67                lat_2 = 42.75 + layoutZone;
     68            }});
     69        } catch (ProjectionConfigurationException e) {
     70            throw new RuntimeException(e);
     71        }
    6572    }
    6673
  • trunk/src/org/openstreetmap/josm/data/projection/LambertEST.java

    r4285 r5066  
    88import org.openstreetmap.josm.data.projection.datum.GRS80Datum;
    99import org.openstreetmap.josm.data.projection.proj.LambertConformalConic;
     10import org.openstreetmap.josm.data.projection.proj.ProjParameters;
    1011
    1112/**
    1213 * Estonian Coordinate System of 1997.
    13  * 
     14 *
    1415 * Thanks to Johan Montagnat and its geoconv java converter application
    1516 * (http://www.i3s.unice.fr/~johan/gps/ , published under GPL license)
     
    2223        datum = GRS80Datum.INSTANCE;
    2324        lon_0 = 24;
    24         double lat_0 = 57.517553930555555555555555555556;
    25         double lat_1 = 59 + 1.0/3.0;
    26         double lat_2 = 58;
    2725        x_0 = 500000;
    2826        y_0 = 6375000;
    2927        proj = new LambertConformalConic();
    30         ((LambertConformalConic) proj).updateParameters2SP(ellps, lat_0, lat_1, lat_2);
     28        try {
     29            proj.initialize(new ProjParameters() {{
     30                ellps = LambertEST.this.ellps;
     31                lat_0 = 57.517553930555555555555555555556;
     32                lat_1 = 59.0 + 1.0/3.0;
     33                lat_2 = 58.0;
     34            }});
     35        } catch (ProjectionConfigurationException e) {
     36            throw new RuntimeException(e);
     37        }
    3138    }
    3239
  • trunk/src/org/openstreetmap/josm/data/projection/Mercator.java

    r4285 r5066  
    77import org.openstreetmap.josm.data.coor.LatLon;
    88import org.openstreetmap.josm.data.projection.datum.WGS84Datum;
     9import org.openstreetmap.josm.data.projection.proj.ProjParameters;
    910
    1011/**
     
    2526        datum = WGS84Datum.INSTANCE;
    2627        proj = new org.openstreetmap.josm.data.projection.proj.Mercator();
     28        try {
     29            proj.initialize(new ProjParameters());
     30        } catch (ProjectionConfigurationException e) {
     31            throw new RuntimeException(e);
     32        }
    2733    }
    2834
    29     @Override 
     35    @Override
    3036    public String toString() {
    3137        return tr("Mercator");
     
    3440    @Override
    3541    public Integer getEpsgCode() {
    36         /* initially they used 3785 but that has been superseded, 
     42        /* initially they used 3785 but that has been superseded,
    3743         * see http://www.epsg-registry.org/ */
    3844        return 3857;
  • trunk/src/org/openstreetmap/josm/data/projection/Puwg.java

    r4285 r5066  
    1717import org.openstreetmap.josm.data.coor.LatLon;
    1818import org.openstreetmap.josm.data.projection.datum.GRS80Datum;
     19import org.openstreetmap.josm.data.projection.proj.ProjParameters;
    1920import org.openstreetmap.josm.tools.GBC;
    2021
     
    2627 */
    2728public class Puwg extends AbstractProjection implements ProjectionSubPrefs {
    28    
     29
    2930    public static final int DEFAULT_ZONE = 0;
    30    
     31
    3132    private int zone;
    3233
     
    4546    public Puwg(int zone) {
    4647        ellps = Ellipsoid.GRS80;
    47         proj = new org.openstreetmap.josm.data.projection.proj.TransverseMercator(ellps);
     48        proj = new org.openstreetmap.josm.data.projection.proj.TransverseMercator();
     49        try {
     50            proj.initialize(new ProjParameters() {{ ellps = Puwg.this.ellps; }});
     51        } catch (ProjectionConfigurationException e) {
     52            throw new RuntimeException(e);
     53        }
    4854        datum = GRS80Datum.INSTANCE;
    4955        updateParameters(zone);
    5056    }
    51    
     57
    5258    public void updateParameters(int zone) {
    5359        this.zone = zone;
     
    5965    }
    6066
    61     @Override 
     67    @Override
    6268    public String toString() {
    6369        return tr("PUWG (Poland)");
     
    176182        return 2180;
    177183    }
    178    
     184
    179185    @Override
    180186    public String toCode() {
  • trunk/src/org/openstreetmap/josm/data/projection/SwissGrid.java

    r4341 r5066  
    1414import org.openstreetmap.josm.data.coor.LatLon;
    1515import org.openstreetmap.josm.data.projection.datum.ThreeParameterDatum;
     16import org.openstreetmap.josm.data.projection.proj.ProjParameters;
    1617import org.openstreetmap.josm.data.projection.proj.SwissObliqueMercator;
    1718import org.openstreetmap.josm.gui.widgets.HtmlPanel;
     
    2021/**
    2122 * SwissGrid CH1903 / L03, see http://de.wikipedia.org/wiki/Swiss_Grid.
    22  * 
     23 *
    2324 * Actually, what we have here, is CH1903+ (EPSG:2056), but without
    2425 * the additional false easting of 2000km and false northing 1000 km.
     
    2627 * To get to CH1903, a shift file is required. So currently, there are errors
    2728 * up to 1.6m (depending on the location).
    28  * 
     29 *
    2930 * This projection does not have any parameters, it only implements
    3031 * ProjectionSubPrefs to show a warning that the grid file correction is not done.
     
    3839        y_0 = 200000;
    3940        lon_0 = 7.0 + 26.0/60 + 22.50/3600;
    40         double lat_0 = 46.0 + 57.0/60 + 8.66/3600;
    41         proj = new SwissObliqueMercator(ellps, lat_0);
     41        proj = new SwissObliqueMercator();
     42        try {
     43            proj.initialize(new ProjParameters() {{
     44                ellps = SwissGrid.this.ellps;
     45                lat_0 = 46.0 + 57.0/60 + 8.66/3600;
     46            }});
     47        } catch (ProjectionConfigurationException e) {
     48            throw new RuntimeException(e);
     49        }
    4250    }
    4351
  • trunk/src/org/openstreetmap/josm/data/projection/TransverseMercatorLV.java

    r4285 r5066  
    77import org.openstreetmap.josm.data.coor.LatLon;
    88import org.openstreetmap.josm.data.projection.datum.GRS80Datum;
     9import org.openstreetmap.josm.data.projection.proj.ProjParameters;
    910
    1011/**
     
    1819    public TransverseMercatorLV() {
    1920        ellps = Ellipsoid.GRS80;
    20         proj = new org.openstreetmap.josm.data.projection.proj.TransverseMercator(ellps);
     21        proj = new org.openstreetmap.josm.data.projection.proj.TransverseMercator();
     22        try {
     23            proj.initialize(new ProjParameters() {{ ellps = TransverseMercatorLV.this.ellps; }});
     24        } catch (ProjectionConfigurationException e) {
     25            throw new RuntimeException(e);
     26        }
    2127        datum = GRS80Datum.INSTANCE;
    2228        lon_0 = 24;
     
    2531        k_0 = 0.9996;
    2632    }
    27    
    28     @Override 
     33
     34    @Override
    2935    public String toString() {
    3036        return tr("LKS-92 (Latvia TM)");
  • trunk/src/org/openstreetmap/josm/data/projection/UTM.java

    r4285 r5066  
    2020import org.openstreetmap.josm.data.coor.LatLon;
    2121import org.openstreetmap.josm.data.projection.datum.GRS80Datum;
     22import org.openstreetmap.josm.data.projection.proj.ProjParameters;
    2223import org.openstreetmap.josm.tools.GBC;
    2324
     
    4849    public UTM(int zone, Hemisphere hemisphere, boolean offset) {
    4950        ellps = Ellipsoid.GRS80;
    50         proj = new org.openstreetmap.josm.data.projection.proj.TransverseMercator(ellps);
     51        proj = new org.openstreetmap.josm.data.projection.proj.TransverseMercator();
     52        try {
     53            proj.initialize(new ProjParameters() {{ ellps = UTM.this.ellps; }});
     54        } catch (ProjectionConfigurationException e) {
     55            throw new RuntimeException(e);
     56        }
    5157        datum = GRS80Datum.INSTANCE;
    5258        updateParameters(zone, hemisphere, offset);
  • trunk/src/org/openstreetmap/josm/data/projection/UTM_France_DOM.java

    r4285 r5066  
    1919import org.openstreetmap.josm.data.projection.datum.SevenParameterDatum;
    2020import org.openstreetmap.josm.data.projection.datum.ThreeParameterDatum;
     21import org.openstreetmap.josm.data.projection.proj.ProjParameters;
    2122import org.openstreetmap.josm.tools.GBC;
    2223
     
    2425 * This class implements all projections for French departements in the Caribbean Sea and
    2526 * Indian Ocean using the UTM transvers Mercator projection and specific geodesic settings (7 parameters transformation algorithm).
    26  * 
     27 *
    2728 */
    2829public class UTM_France_DOM extends AbstractProjection implements ProjectionSubPrefs {
     
    7576        updateParameters(DEFAULT_GEODESIC);
    7677    }
    77    
     78
    7879    public void updateParameters(int currentGeodesic) {
    7980        this.currentGeodesic = currentGeodesic;
    8081        datum = utmDatums[currentGeodesic];
    8182        ellps = datum.getEllipsoid();
    82         proj = new org.openstreetmap.josm.data.projection.proj.TransverseMercator(ellps);
     83        proj = new org.openstreetmap.josm.data.projection.proj.TransverseMercator();
     84        try {
     85            proj.initialize(new ProjParameters() {{ ellps = UTM_France_DOM.this.ellps; }});
     86        } catch (ProjectionConfigurationException e) {
     87            throw new RuntimeException(e);
     88        }
    8389        isNorth = currentGeodesic != 3;
    8490        zone = utmZones[currentGeodesic];
     
    8894        k_0 = 0.9996;
    8995    }
    90    
     96
    9197    public int getCurrentGeodesic() {
    9298        return currentGeodesic;
    9399    }
    94100
    95     @Override 
     101    @Override
    96102    public String toString() {
    97103        return tr("UTM France (DOM)");
  • trunk/src/org/openstreetmap/josm/data/projection/proj/LambertConformalConic.java

    r5040 r5066  
    77
    88import org.openstreetmap.josm.data.projection.Ellipsoid;
     9import org.openstreetmap.josm.data.projection.ProjectionConfigurationException;
    910
    1011/**
     
    1415 */
    1516public class LambertConformalConic implements Proj {
    16    
     17
    1718    protected Ellipsoid ellps;
    1819    protected double e;
    19    
     20
    2021    public static abstract class Parameters {
    2122        public final double latitudeOrigin;
     
    2425        }
    2526    };
    26    
     27
    2728    public static class Parameters1SP extends Parameters {
    2829        public Parameters1SP(double latitudeOrigin) {
     
    4243
    4344    private Parameters params;
    44    
     45
    4546    /**
    4647     * projection exponent
     
    5253    protected double F;
    5354    /**
    54      * radius of the parallel of latitude of the false origin (2SP) or at 
     55     * radius of the parallel of latitude of the false origin (2SP) or at
    5556     * natural origin (1SP)
    5657     */
    57     protected double r0; 
    58    
     58    protected double r0;
     59
    5960    /**
    6061     * precision in iterative schema
     
    6263    protected static final double epsilon = 1e-12;
    6364
    64     /**
    65      * Constructor.
    66      * Call one of the updateParameters... methods for initialization.
    67      */
    68     public LambertConformalConic() {
     65    @Override
     66    public void initialize(ProjParameters params) throws ProjectionConfigurationException {
     67        ellps = params.ellps;
     68        e = ellps.e;
     69        if (params.lcc_n != null && params.lcc_F != null && params.lcc_r0 != null) {
     70            initializeDirect(params.lcc_n, params.lcc_F, params.lcc_r0);
     71        } else {
     72            if (params.lat_0 == null)
     73                throw new ProjectionConfigurationException(tr("Parameter ''{0}'' required.", "lat_0"));
     74            if (params.lat_1 != null && params.lat_2 != null) {
     75                initialize2SP(params.lat_0, params.lat_1, params.lat_2);
     76            } else {
     77                initialize1SP(params.lat_0);
     78            }
     79        }
    6980    }
    7081
    7182    /**
    7283     * Initialize for LCC with 2 standard parallels.
    73      *
    74      * @param ellps the ellipsoid
     84     *
    7585     * @param lat_0 latitude of false origin (in degrees)
    7686     * @param lat_1 latitude of first standard parallel (in degrees)
    7787     * @param lat_2 latitude of second standard parallel (in degrees)
    7888     */
    79     public void updateParameters2SP(Ellipsoid ellps, double lat_0, double lat_1, double lat_2) {
     89    private void initialize2SP(double lat_0, double lat_1, double lat_2) {
    8090        this.params = new Parameters2SP(lat_0, lat_1, lat_2);
    81         this.ellps = ellps;
    82         this.e = ellps.e;
    83        
     91
    8492        final double m1 = m(toRadians(lat_1));
    8593        final double m2 = m(toRadians(lat_2));
    86        
     94
    8795        final double t1 = t(toRadians(lat_1));
    8896        final double t2 = t(toRadians(lat_2));
    8997        final double tf = t(toRadians(lat_0));
    90        
     98
    9199        n  = (log(m1) - log(m2)) / (log(t1) - log(t2));
    92100        F  = m1 / (n * pow(t1, n));
    93101        r0 = F * pow(tf, n);
    94102    }
    95    
     103
    96104    /**
    97105     * Initialize for LCC with 1 standard parallel.
    98      *
    99      * @param ellps the ellipsoid
     106     *
    100107     * @param lat_0 latitude of natural origin (in degrees)
    101108     */
    102     public void updateParameters1SP(Ellipsoid ellps, double lat_0) {
     109    private void initialize1SP(double lat_0) {
    103110        this.params = new Parameters1SP(lat_0);
    104         this.ellps = ellps;
    105         this.e = ellps.e;
    106111        final double lat_0_rad = toRadians(lat_0);
    107        
     112
    108113        final double m0 = m(lat_0_rad);
    109114        final double t0 = t(lat_0_rad);
    110        
     115
    111116        n = sin(lat_0_rad);
    112117        F  = m0 / (n * pow(t0, n));
     
    116121    /**
    117122     * Initialize LCC by providing the projection parameters directly.
    118      *
    119      * @param ellps the ellipsoid
     123     *
    120124     * @param n see field n
    121125     * @param F see field F
    122126     * @param r0 see field r0
    123127     */
    124     public void updateParametersDirect(Ellipsoid ellps, double n, double F, double r0) {
     128    private void initializeDirect(double n, double F, double r0) {
    125129        this.params = null;
    126         this.ellps = ellps;
    127         this.e = ellps.e;
    128130        this.n = n;
    129131        this.F = F;
     
    145147        return cos(lat_rad) / (sqrt(1 - e * e * pow(sin(lat_rad), 2)));
    146148    }
    147    
     149
    148150    @Override
    149151    public String getName() {
     
    166168        return new double[] { X, Y };
    167169    }
    168    
     170
    169171    @Override
    170172    public double[] invproject(double east, double north) {
     
    176178        return new double[] { phi, lambda };
    177179    }
    178    
     180
    179181    public final Parameters getParameters() {
    180182        return params;
  • trunk/src/org/openstreetmap/josm/data/projection/proj/Mercator.java

    r4285 r5066  
    66import static org.openstreetmap.josm.tools.I18n.tr;
    77
     8import org.openstreetmap.josm.data.projection.ProjectionConfigurationException;
     9
    810/**
    911 * Mercator Projection.
    1012 */
    1113public class Mercator implements Proj {
    12    
     14
    1315    @Override
    1416    public String getName() {
     
    1921    public String getProj4Id() {
    2022        return "merc";
     23    }
     24
     25    @Override
     26    public void initialize(ProjParameters params) throws ProjectionConfigurationException {
    2127    }
    2228
  • trunk/src/org/openstreetmap/josm/data/projection/proj/Proj.java

    r4285 r5066  
    22package org.openstreetmap.josm.data.projection.proj;
    33
     4import org.openstreetmap.josm.data.projection.ProjectionConfigurationException;
     5
    46/**
    57 * A projection (in the narrow sense).
    6  * 
     8 *
    79 * Converts lat/lon the east/north and the other way around.
    8  * 
    9  * Datum conversion, false easting / northing, origin of longitude 
     10 *
     11 * Datum conversion, false easting / northing, origin of longitude
    1012 * and general scale factor is already applied when the projection is invoked.
    11  * 
     13 *
    1214 * Lat/lon is not in degrees, but in radians (unlike other parts of JOSM).
    13  * Additional parameters in the constructor arguments are usually still in 
    14  * degrees. So to avoid confusion, you can follow the convention, that 
     15 * Additional parameters in the constructor arguments are usually still in
     16 * degrees. So to avoid confusion, you can follow the convention, that
    1517 * coordinates in radians are called lat_rad/lon_rad or phi/lambda.
    16  * 
    17  * East/north values are not in meters, but in meters divided by the semi major 
    18  * axis of the ellipsoid (earth radius). (Usually this is what you get anyway, 
     18 *
     19 * East/north values are not in meters, but in meters divided by the semi major
     20 * axis of the ellipsoid (earth radius). (Usually this is what you get anyway,
    1921 * unless you multiply by 'a' somehow implicitly or explicitly.)
    2022 *
     
    2830    /**
    2931     * The Proj.4 identifier.
    30      * 
     32     *
    3133     * (as reported by cs2cs -lp)
    3234     * If no id exists, return null.
    3335     */
    3436    String getProj4Id();
    35    
     37
     38    /**
     39     * Initialize the projection using the provided parameters.
     40     *
     41     * @throws ProjectionConfigurationException in case parameters are not suitable
     42     */
     43    void initialize(ProjParameters params) throws ProjectionConfigurationException;
     44
    3645    /**
    3746     * Convert lat/lon to east/north.
    38      * 
     47     *
    3948     * @param lat_rad the latitude in radians
    4049     * @param lon_rad the longitude in radians
     
    4352     */
    4453    double[] project(double lat_rad, double lon_rad);
    45    
     54
    4655    /**
    4756     * Convert east/north to lat/lon.
    48      * 
     57     *
    4958     * @param east east value in meters, divided by the semi major axis of the ellipsoid
    5059     * @param north north value in meters, divided by the semi major axis of the ellipsoid
     
    5261     */
    5362    double[] invproject(double east, double north);
     63
    5464}
  • trunk/src/org/openstreetmap/josm/data/projection/proj/SwissObliqueMercator.java

    r4285 r5066  
    77
    88import org.openstreetmap.josm.data.projection.Ellipsoid;
     9import org.openstreetmap.josm.data.projection.ProjectionConfigurationException;
    910
    1011/**
     
    1920public class SwissObliqueMercator implements Proj {
    2021
    21     private final Ellipsoid ellps;
     22    private Ellipsoid ellps;
    2223    private double kR;
    2324    private double alpha;
    2425    private double b0;
    2526    private double K;
    26    
     27
    2728    private static final double EPSILON = 1e-11;
    28    
    29     public SwissObliqueMercator(Ellipsoid ellps, double lat_0) {
    30         this.ellps = ellps;
    31         updateParameters(lat_0);
     29
     30    @Override
     31    public void initialize(ProjParameters params) throws ProjectionConfigurationException {
     32        if (params.lat_0 == null)
     33            throw new ProjectionConfigurationException(tr("Parameter ''{0}'' required.", "lat_0"));
     34        ellps = params.ellps;
     35        initialize(params.lat_0);
    3236    }
    3337
    34     public void updateParameters(double lat_0) {
     38    private void initialize(double lat_0) {
    3539        double phi0 = toRadians(lat_0);
    3640        kR = sqrt(1 - ellps.e2) / (1 - (ellps.e2 * pow(sin(phi0), 2)));
     
    4145            * log((1 + ellps.e * sin(phi0)) / (1 - ellps.e * sin(phi0)));
    4246    }
    43    
     47
    4448    @Override
    4549    public String getName() {
     
    9498        return new double[] { phi, lambda };
    9599    }
    96    
     100
    97101}
  • trunk/src/org/openstreetmap/josm/data/projection/proj/TransverseMercator.java

    r4285 r5066  
    77
    88import org.openstreetmap.josm.data.projection.Ellipsoid;
     9import org.openstreetmap.josm.data.projection.ProjectionConfigurationException;
    910
    1011/**
     
    1314 * @author Dirk Stöcker
    1415 * code based on JavaScript from Chuck Taylor
    15  * 
     16 *
    1617 */
    1718public class TransverseMercator implements Proj {
     
    1920    protected double a, b;
    2021
    21     public TransverseMercator(Ellipsoid ellps) {
    22         this.a = ellps.a;
    23         this.b = ellps.b;
    24     }
    25    
    2622    @Override
    2723    public String getName() {
     
    3228    public String getProj4Id() {
    3329        return "tmerc";
     30    }
     31
     32    @Override
     33    public void initialize(ProjParameters params) throws ProjectionConfigurationException {
     34        this.a = params.ellps.a;
     35        this.b = params.ellps.b;
    3436    }
    3537
     
    4143     * Reference: Hoffmann-Wellenhof, B., Lichtenegger, H., and Collins, J.,
    4244     * GPS: Theory and Practice, 3rd ed.  New York: Springer-Verlag Wien, 1994.
    43      * 
     45     *
    4446     * @param phi Latitude of the point, in radians
    4547     * @param lambda Longitude of the point, in radians
     
    4951    @Override
    5052    public double[] project(double phi, double lambda) {
    51        
     53
    5254        /* Precalculate ep2 */
    5355        double ep2 = (pow(a, 2.0) - pow(b, 2.0)) / pow(b, 2.0);
     
    105107     * Reference: Hoffmann-Wellenhof, B., Lichtenegger, H., and Collins, J.,
    106108     *   GPS: Theory and Practice, 3rd ed.  New York: Springer-Verlag Wien, 1994.
    107      * 
     109     *
    108110     * Remarks:
    109111     *   The local variables Nf, nuf2, tf, and tf2 serve the same purpose as
     
    113115     *   x1frac, x2frac, x2poly, x3poly, etc. are to enhance readability and
    114116     *   to optimize computations.
    115      * 
     117     *
    116118     * @param x The easting of the point, in meters, divided by the semi major axis of the ellipsoid
    117119     * @param y The northing of the point, in meters, divided by the semi major axis of the ellipsoid
     
    190192                        + x7frac * x7poly * pow(x, 7.0) };
    191193    }
    192    
     194
    193195    /**
    194196     * ArcLengthOfMeridian
     
    199201     * Reference: Hoffmann-Wellenhof, B., Lichtenegger, H., and Collins, J.,
    200202     * GPS: Theory and Practice, 3rd ed.  New York: Springer-Verlag Wien, 1994.
    201      * 
     203     *
    202204     * @param phi Latitude of the point, in radians
    203205     * @return The ellipsoidal distance of the point from the equator
     
    234236                    + (epsilon * sin(8.0 * phi)));
    235237    }
    236        
     238
    237239    /**
    238240     * FootpointLatitude
     
    243245     * Reference: Hoffmann-Wellenhof, B., Lichtenegger, H., and Collins, J.,
    244246     *   GPS: Theory and Practice, 3rd ed.  New York: Springer-Verlag Wien, 1994.
    245      * 
     247     *
    246248     * @param y northing coordinate, in meters, divided by the semi major axis of the ellipsoid
    247249     * @return The footpoint latitude, in radians
     
    280282            + (epsilon_ * sin(8.0 * y_));
    281283    }
    282    
     284
    283285}
Note: See TracChangeset for help on using the changeset viewer.