Ignore:
Timestamp:
2016-06-15T10:30:37+02:00 (3 years ago)
Author:
Don-vip
Message:

Checkstyle 6.19: enable SingleSpaceSeparator and fix violations

Location:
trunk/src/org/openstreetmap/josm/data/projection/proj
Files:
7 edited

Legend:

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

    r10250 r10378  
    9292        //  Compute constants for the mlfn
    9393        double t;
     94        // CHECKSTYLE.OFF: SingleSpaceSeparator
    9495        en0 = C00 - e2  *  (C02 + e2  *
    9596             (C04 + e2  *  (C06 + e2  * C08)));
     
    100101        en3 = (t *= e2) *  (C66 - e2  * C68);
    101102        en4 =   t * e2  *  C88;
     103        // CHECKSTYLE.ON: SingleSpaceSeparator
    102104    }
    103105
     
    158160        double phi = (Math.PI/2) - 2.0 * Math.atan(ts);
    159161        for (int i = 0; i < MAXIMUM_ITERATIONS; i++) {
    160             final double con  = e * Math.sin(phi);
     162            final double con = e * Math.sin(phi);
    161163            final double dphi = (Math.PI/2) - 2.0*Math.atan(ts * Math.pow((1-con)/(1+con), eccnth)) - phi;
    162164            phi += dphi;
  • trunk/src/org/openstreetmap/josm/data/projection/proj/AlbersEqualArea.java

    r10235 r10378  
    9898            throw new ProjectionConfigurationException(tr("standard parallels are opposite"));
    9999        }
    100         double  sinphi = Math.sin(phi1);
    101         double  cosphi = Math.cos(phi1);
    102         double  n      = sinphi;
     100        double sinphi = Math.sin(phi1);
     101        double cosphi = Math.cos(phi1);
     102        double n = sinphi;
    103103        boolean secant = Math.abs(phi1 - phi2) >= EPSILON;
    104104        double m1 = msfn(sinphi, cosphi);
    105105        double q1 = qsfn(sinphi);
    106106        if (secant) { // secant cone
    107             sinphi    = Math.sin(phi2);
    108             cosphi    = Math.cos(phi2);
     107            sinphi = Math.sin(phi2);
     108            cosphi = Math.cos(phi2);
    109109            double m2 = msfn(sinphi, cosphi);
    110110            double q2 = qsfn(sinphi);
     
    130130        }
    131131        rho = Math.sqrt(rho) / n;
    132         y   = rho0 - rho * Math.cos(x);
    133         x   =        rho * Math.sin(x);
     132        // CHECKSTYLE.OFF: SingleSpaceSeparator
     133        y = rho0 - rho * Math.cos(x);
     134        x =        rho * Math.sin(x);
     135        // CHECKSTYLE.ON: SingleSpaceSeparator
    134136        return new double[] {x, y};
    135137    }
     
    142144            if (n < 0.0) {
    143145                rho = -rho;
    144                 x   = -x;
    145                 y   = -y;
     146                x = -x;
     147                y = -y;
    146148            }
    147149            x = Math.atan2(x, y) / n;
     
    175177            final double sinpi = Math.sin(phi);
    176178            final double cospi = Math.cos(phi);
    177             final double con   = e * sinpi;
    178             final double com   = 1.0 - con*con;
    179             final double dphi  = 0.5 * com*com / cospi *
     179            final double con = e * sinpi;
     180            final double com = 1.0 - con*con;
     181            final double dphi = 0.5 * com*com / cospi *
    180182                    (qs/toneEs - sinpi / com + 0.5/e * Math.log((1. - con) / (1. + con)));
    181183            phi += dphi;
  • trunk/src/org/openstreetmap/josm/data/projection/proj/LambertAzimuthalEqualArea.java

    r9998 r10378  
    100100
    101101        final double sinphi;
    102         qp     = qsfn(1);
    103         rq     = Math.sqrt(0.5 * qp);
     102        qp = qsfn(1);
     103        rq = Math.sqrt(0.5 * qp);
    104104        sinphi = Math.sin(latitudeOfOrigin);
    105105        sinb1 = qsfn(sinphi) / qp;
     
    107107        switch (mode) {
    108108            case NORTH_POLE:  // Fall through
    109             case SOUTH_POLE: {
    110                 dd  = 1.0;
     109            case SOUTH_POLE:
     110                dd = 1.0;
    111111                xmf = ymf = rq;
    112112                break;
    113             }
    114             case EQUATORIAL: {
    115                 dd  = 1.0 / rq;
     113            case EQUATORIAL:
     114                dd = 1.0 / rq;
    116115                xmf = 1.0;
    117116                ymf = 0.5 * qp;
    118117                break;
    119             }
    120             case OBLIQUE: {
    121                 dd  = Math.cos(latitudeOfOrigin) /
    122                         (Math.sqrt(1.0 - e2 * sinphi * sinphi) * rq * cosb1);
     118            case OBLIQUE:
     119                dd = Math.cos(latitudeOfOrigin) / (Math.sqrt(1.0 - e2 * sinphi * sinphi) * rq * cosb1);
    123120                xmf = rq * dd;
    124121                ymf = rq / dd;
    125122                break;
    126             }
    127             default: {
     123            default:
    128124                throw new AssertionError(mode);
    129             }
    130125        }
    131126    }
     
    139134        final double sinb, cosb, b, c, x, y;
    140135        switch (mode) {
    141             case OBLIQUE: {
     136            case OBLIQUE:
    142137                sinb = q / qp;
    143138                cosb = Math.sqrt(1.0 - sinb * sinb);
    144                 c    = 1.0 + sinb1 * sinb + cosb1 * cosb * coslam;
    145                 b    = Math.sqrt(2.0 / c);
    146                 y    = ymf * b * (cosb1 * sinb - sinb1 * cosb * coslam);
    147                 x    = xmf * b * cosb * sinlam;
    148                 break;
    149             }
    150             case EQUATORIAL: {
     139                c = 1.0 + sinb1 * sinb + cosb1 * cosb * coslam;
     140                b = Math.sqrt(2.0 / c);
     141                y = ymf * b * (cosb1 * sinb - sinb1 * cosb * coslam);
     142                x = xmf * b * cosb * sinlam;
     143                break;
     144            case EQUATORIAL:
    151145                sinb = q / qp;
    152146                cosb = Math.sqrt(1.0 - sinb * sinb);
    153                 c    = 1.0 + cosb * coslam;
    154                 b    = Math.sqrt(2.0 / c);
    155                 y    = ymf * b * sinb;
    156                 x    = xmf * b * cosb * sinlam;
    157                 break;
    158             }
    159             case NORTH_POLE: {
     147                c = 1.0 + cosb * coslam;
     148                b = Math.sqrt(2.0 / c);
     149                y = ymf * b * sinb;
     150                x = xmf * b * cosb * sinlam;
     151                break;
     152            case NORTH_POLE:
    160153                c = (Math.PI / 2) + phi;
    161154                q = qp - q;
     
    168161                }
    169162                break;
    170             }
    171             case SOUTH_POLE: {
     163            case SOUTH_POLE:
    172164                c = phi - (Math.PI / 2);
    173165                q = qp + q;
     
    180172                }
    181173                break;
    182             }
    183             default: {
     174            default:
    184175                throw new AssertionError(mode);
    185             }
    186176        }
    187177        if (Math.abs(c) < EPSILON_LATITUDE) {
     
    211201                    if (mode == Mode.OBLIQUE) {
    212202                        ab = cCe * sinb1 + y * sCe * cosb1 / rho;
    213                         y  = rho * cosb1 * cCe - y * sinb1 * sCe;
     203                        y = rho * cosb1 * cCe - y * sinb1 * sCe;
    214204                    } else {
    215205                        ab = y * sCe / rho;
    216                         y  = rho * cCe;
     206                        y = rho * cCe;
    217207                    }
    218208                    lambda = Math.atan2(x, y);
  • trunk/src/org/openstreetmap/josm/data/projection/proj/LambertConformalConic.java

    r10001 r10378  
    105105        final double tf = t(toRadians(lat0));
    106106
    107         n  = (log(m1) - log(m2)) / (log(t1) - log(t2));
    108         f  = m1 / (n * pow(t1, n));
     107        n = (log(m1) - log(m2)) / (log(t1) - log(t2));
     108        f = m1 / (n * pow(t1, n));
    109109        r0 = f * pow(tf, n);
    110110    }
     
    123123
    124124        n = sin(lat0rad);
    125         f  = m0 / (n * pow(t0, n));
     125        f = m0 / (n * pow(t0, n));
    126126        r0 = f * pow(t0, n);
    127127    }
  • trunk/src/org/openstreetmap/josm/data/projection/proj/Mercator.java

    r9577 r10378  
    7272            if (spherical) {
    7373                scaleFactor *= Math.cos(standardParallel);
    74             }  else {
     74            } else {
    7575                scaleFactor *= msfn(Math.sin(standardParallel), Math.cos(standardParallel));
    7676            }
  • trunk/src/org/openstreetmap/josm/data/projection/proj/ObliqueMercator.java

    r10001 r10378  
    314314            lonCenter = Math.toRadians(params.lonc);
    315315            azimuth = Math.toRadians(params.alpha);
     316            // CHECKSTYLE.OFF: SingleSpaceSeparator
    316317            if ((azimuth > -1.5*Math.PI && azimuth < -0.5*Math.PI) ||
    317318                (azimuth >  0.5*Math.PI && azimuth <  1.5*Math.PI)) {
     
    319320                        tr("Illegal value for parameter ''{0}'': {1}", "alpha", Double.toString(params.alpha)));
    320321            }
     322            // CHECKSTYLE.ON: SingleSpaceSeparator
    321323            if (params.gamma != null) {
    322324                rectifiedGridAngle = Math.toRadians(params.gamma);
     
    341343        singamma0 = Math.sin(gamma0);
    342344        cosgamma0 = Math.cos(gamma0);
    343         sinrot    = Math.sin(rectifiedGridAngle);
    344         cosrot    = Math.cos(rectifiedGridAngle);
    345         arb       = a / b;
    346         ab        = a * b;
    347         bra       = b / a;
    348         vPoleN  = arb * Math.log(Math.tan(0.5 * (Math.PI/2.0 - gamma0)));
    349         vPoleS  = arb * Math.log(Math.tan(0.5 * (Math.PI/2.0 + gamma0)));
     345        sinrot = Math.sin(rectifiedGridAngle);
     346        cosrot = Math.cos(rectifiedGridAngle);
     347        arb = a / b;
     348        ab = a * b;
     349        bra = b / a;
     350        vPoleN = arb * Math.log(Math.tan(0.5 * (Math.PI/2.0 - gamma0)));
     351        vPoleS = arb * Math.log(Math.tan(0.5 * (Math.PI/2.0 + gamma0)));
    350352        boolean hotine = params.no_off != null && params.no_off;
    351353        if (hotine) {
  • trunk/src/org/openstreetmap/josm/data/projection/proj/PolarStereographic.java

    r10235 r10378  
    135135        } else {
    136136            final double rho = k0 * tsfn(y, sinlat);
    137             x =  rho * sinlon;
     137            x = rho * sinlon;
    138138            y = -rho * coslon;
    139139        }
Note: See TracChangeset for help on using the changeset viewer.