Examples of org.opengis.parameter.ParameterValueGroup

org.opengis.parameter.ParameterValueGroup
engeospatial.org/files/?artifact_id=6716">Abstract specification 2.0 @author Martin Desruisseaux (IRD) @author Jody Garnett (Refractions Research) @since GeoAPI 1.0 @see ParameterDescriptorGroup @see ParameterValue

   * @throws GeoTiffException
   */
  private ParameterValueGroup setParametersForProjection(String name,
      final String coordTransCode,
      final GeoTiffIIOMetadataDecoder metadata) throws GeoTiffException {
    ParameterValueGroup parameters = null;
    try {
      int code = 0;
      if (coordTransCode != null)
        code = Integer.parseInt(coordTransCode);
      if (name == null)
        name = "unnamed";
      /**
       * 
       * Transverse Mercator
       * 
       */
      if (name.equalsIgnoreCase("transverse_mercator")
          || code == GeoTiffCoordinateTransformationsCodes.CT_TransverseMercator) {
        parameters = mtFactory
            .getDefaultParameters("transverse_mercator");
        parameters.parameter("central_meridian").setValue(
            getOriginLong(metadata));
        parameters.parameter("latitude_of_origin").setValue(
            getOriginLat(metadata));
        parameters.parameter("scale_factor").setValue(
            getGeoKeyAsDouble(
                GeoTiffPCSCodes.ProjScaleAtNatOriginGeoKey,
                metadata));
        parameters.parameter("false_easting").setValue(
            getFalseEasting(metadata));
        parameters.parameter("false_northing").setValue(
            getFalseNorthing(metadata));


        return parameters;
      }


      /**
       * 
       * Equidistant Cylindrical - Plate Caree - Equirectangular
       * 
       */
      if (name.equalsIgnoreCase("Equidistant_Cylindrical")
          || name.equalsIgnoreCase("Plate_Carree")
          || name.equalsIgnoreCase("Equidistant_Cylindrical")
          || code == GeoTiffCoordinateTransformationsCodes.CT_Equirectangular) {
        parameters = mtFactory
            .getDefaultParameters("Equidistant_Cylindrical");
        parameters.parameter("latitude_of_origin").setValue(
            getOriginLat(metadata));
        parameters.parameter("central_meridian").setValue(
            getOriginLong(metadata));


        parameters.parameter("false_easting").setValue(
            getFalseEasting(metadata));
        parameters.parameter("false_northing").setValue(
            getFalseNorthing(metadata));


        return parameters;
      }
      /**
       * 
       * Mercator_1SP
       * Mercator_2SP
       * 
       */
      if (name.equalsIgnoreCase("mercator_1SP")
          || name.equalsIgnoreCase("Mercator_2SP")
          || code == GeoTiffCoordinateTransformationsCodes.CT_Mercator) {
          
              final double standard_parallel_1 = 
                                getGeoKeyAsDouble(GeoTiffPCSCodes.ProjStdParallel1GeoKey,
                                                    metadata);
              boolean isMercator2SP = false;
              if (!Double.isNaN(standard_parallel_1)){
                  parameters = mtFactory.getDefaultParameters("Mercator_2SP");
                  isMercator2SP = true;
              }
              else
                  parameters = mtFactory.getDefaultParameters("Mercator_1SP");
              
              parameters.parameter("central_meridian").setValue(getOriginLong(metadata));
        parameters.parameter("latitude_of_origin").setValue(getOriginLat(metadata));
        parameters.parameter("false_easting").setValue(
            getFalseEasting(metadata));
        parameters.parameter("false_northing").setValue(
            getFalseNorthing(metadata));
        if (isMercator2SP)
            parameters.parameter("standard_parallel_1").setValue(standard_parallel_1);
        else
            parameters.parameter("scale_factor").setValue(getScaleFactor(metadata));
        return parameters;
      }


      /**
       * 
       * Lambert_conformal_conic_1SP
       * 
       */
      if (name.equalsIgnoreCase("lambert_conformal_conic_1SP")
          || code == GeoTiffCoordinateTransformationsCodes.CT_LambertConfConic_Helmert) {
        parameters = mtFactory
            .getDefaultParameters("lambert_conformal_conic_1SP");
        parameters.parameter("central_meridian").setValue(
            getOriginLong(metadata));
        parameters.parameter("latitude_of_origin").setValue(
            getOriginLat(metadata));
        parameters.parameter("scale_factor").setValue(
            getGeoKeyAsDouble(
                GeoTiffPCSCodes.ProjScaleAtNatOriginGeoKey,
                metadata));
        parameters.parameter("false_easting").setValue(
            getFalseEasting(metadata));
        parameters.parameter("false_northing").setValue(
            getFalseNorthing(metadata));


        return parameters;
      }


      /**
       * 
       * Lambert_conformal_conic_2SP
       * 
       */
      if (name.equalsIgnoreCase("lambert_conformal_conic_2SP")
          || name
              .equalsIgnoreCase("lambert_conformal_conic_2SP_Belgium")
          || code == GeoTiffCoordinateTransformationsCodes.CT_LambertConfConic_2SP) {
        parameters = mtFactory
            .getDefaultParameters("lambert_conformal_conic_2SP");
        parameters.parameter("central_meridian").setValue(
            getOriginLong(metadata));
        parameters.parameter("latitude_of_origin").setValue(
            getOriginLat(metadata));
        parameters.parameter("standard_parallel_1").setValue(
            getGeoKeyAsDouble(
                GeoTiffPCSCodes.ProjStdParallel1GeoKey,
                metadata));
        parameters.parameter("standard_parallel_2").setValue(
            getGeoKeyAsDouble(
                GeoTiffPCSCodes.ProjStdParallel2GeoKey,
                metadata));
        parameters.parameter("false_easting").setValue(
            getFalseEasting(metadata));
        parameters.parameter("false_northing").setValue(
            getFalseNorthing(metadata));


        return parameters;
      }


      /**
       * 
       * Krovak
       * 
       */
      if (name.equalsIgnoreCase("Krovak")) {
        parameters = mtFactory.getDefaultParameters("Krovak");
        parameters.parameter("longitude_of_center").setValue(
            getOriginLong(metadata));
        parameters.parameter("latitude_of_center").setValue(
            getOriginLat(metadata));
        parameters.parameter("azimuth").setValue(
            getGeoKeyAsDouble(
                GeoTiffPCSCodes.ProjStdParallel1GeoKey,
                metadata));
        parameters.parameter("pseudo_standard_parallel_1").setValue(
            getGeoKeyAsDouble(
                GeoTiffPCSCodes.ProjStdParallel2GeoKey,
                metadata));
        parameters.parameter("scale_factor").setValue(
            getFalseEasting(metadata));


        return parameters;
      }


      // if (name.equalsIgnoreCase("equidistant_conic")
      // || code == GeoTiffMetadata2CRSAdapter.CT_EquidistantConic) {
      // parameters = mtFactory
      // .getDefaultParameters("equidistant_conic");
      // parameters.parameter("central_meridian").setValue(
      // getOriginLong());
      // parameters.parameter("latitude_of_origin").setValue(
      // getOriginLat());
      // parameters
      // .parameter("standard_parallel_1")
      // .setValue(
      // this
      // .getGeoKeyAsDouble(GeoTiffIIOMetadataDecoder.ProjStdParallel1GeoKey));
      // parameters
      // .parameter("standard_parallel_2")
      // .setValue(
      // this
      // .getGeoKeyAsDouble(GeoTiffIIOMetadataDecoder.ProjStdParallel2GeoKey));
      // parameters.parameter("false_easting").setValue(
      // getFalseEasting());
      // parameters.parameter("false_northing").setValue(
      // getFalseNorthing());
      //
      // return parameters;
      // }


      /**
       * 
       * STEREOGRAPHIC
       * 
       */
      if (name.equalsIgnoreCase("stereographic")
          || code == GeoTiffCoordinateTransformationsCodes.CT_Stereographic) {
        parameters = mtFactory.getDefaultParameters("stereographic");
        parameters.parameter("central_meridian").setValue(
            getOriginLong(metadata));


        parameters.parameter("latitude_of_origin").setValue(


        getOriginLat(metadata));
        parameters.parameter("scale_factor").setValue(
            getGeoKeyAsDouble(
                GeoTiffPCSCodes.ProjScaleAtNatOriginGeoKey,
                metadata));
        parameters.parameter("false_easting").setValue(
            getFalseEasting(metadata));
        parameters.parameter("false_northing").setValue(
            getFalseNorthing(metadata));


        return parameters;
      }


      /**
       * 
       * POLAR_STEREOGRAPHIC.
       * 
       */
      if (name.equalsIgnoreCase("polar_stereographic")
          || code == GeoTiffCoordinateTransformationsCodes.CT_PolarStereographic) {
        parameters = mtFactory
            .getDefaultParameters("polar_stereographic");


        parameters.parameter("latitude_of_origin").setValue(
            getOriginLat(metadata));
        parameters.parameter("scale_factor").setValue(
            getGeoKeyAsDouble(
                GeoTiffPCSCodes.ProjScaleAtNatOriginGeoKey,
                metadata));
        parameters.parameter("false_easting").setValue(
            getFalseEasting(metadata));
        parameters.parameter("false_northing").setValue(
            getFalseNorthing(metadata));
        parameters.parameter("central_meridian").setValue(
            getOriginLong(metadata));


        return parameters;
      }
      
      /**
        * Oblique Stereographic
        */
       if(name.equalsIgnoreCase("oblique_stereographic") 
           || code == GeoTiffCoordinateTransformationsCodes.CT_ObliqueStereographic) {
         parameters = mtFactory.getDefaultParameters("Oblique_Stereographic");
         
         parameters.parameter("central_meridian").setValue(
             getOriginLong(metadata));
         parameters.parameter("latitude_of_origin").setValue(
             getOriginLat(metadata));
         parameters.parameter("scale_factor").setValue(
             getGeoKeyAsDouble(
                 GeoTiffPCSCodes.ProjScaleAtNatOriginGeoKey,
                 metadata));
         parameters.parameter("false_easting").setValue(
             getFalseEasting(metadata));
         parameters.parameter("false_northing").setValue(
             getFalseNorthing(metadata));
         return parameters;
       }
             
      /**
       * 
       * OBLIQUE_MERCATOR.
       * 
       */
      if (name.equalsIgnoreCase("oblique_mercator")
          || name.equalsIgnoreCase("hotine_oblique_mercator")
          || code == GeoTiffCoordinateTransformationsCodes.CT_ObliqueMercator) {
        parameters = mtFactory.getDefaultParameters("oblique_mercator");


        parameters.parameter("scale_factor").setValue(
            getScaleFactor(metadata));
        parameters.parameter("azimuth").setValue(
            getGeoKeyAsDouble(
                GeoTiffPCSCodes.ProjAzimuthAngleGeoKey,
                metadata));
        parameters.parameter("false_easting").setValue(
            getFalseEasting(metadata));
        parameters.parameter("false_northing").setValue(
            getFalseNorthing(metadata));
        parameters.parameter("longitude_of_center").setValue(
            getOriginLong(metadata));
        parameters.parameter("latitude_of_center").setValue(
            getOriginLat(metadata));
        return parameters;
      }


      /**
       * 
       * albers_Conic_Equal_Area
       * 
       */
      if (name.equalsIgnoreCase("albers_Conic_Equal_Area")
          || code == GeoTiffCoordinateTransformationsCodes.CT_AlbersEqualArea) {
        parameters = mtFactory
            .getDefaultParameters("Albers_Conic_Equal_Area");
        parameters.parameter("standard_parallel_1").setValue(
            getGeoKeyAsDouble(
                GeoTiffPCSCodes.ProjStdParallel1GeoKey,
                metadata));
        parameters.parameter("standard_parallel_2").setValue(
            getGeoKeyAsDouble(
                GeoTiffPCSCodes.ProjStdParallel2GeoKey,
                metadata));
        parameters.parameter("latitude_of_center").setValue(
            getOriginLat(metadata));
        parameters.parameter("longitude_of_center").setValue(
            getOriginLong(metadata));
        parameters.parameter("false_easting").setValue(
            getFalseEasting(metadata));
        parameters.parameter("false_northing").setValue(
            getFalseNorthing(metadata));


        return parameters;
      }


      /**
       * 
       * Orthographic
       * 
       */
      if (name.equalsIgnoreCase("Orthographic")
          || code == GeoTiffCoordinateTransformationsCodes.CT_Orthographic) {
        parameters = mtFactory.getDefaultParameters("orthographic");


        parameters.parameter("latitude_of_origin").setValue(
            getOriginLat(metadata));
        parameters.parameter("longitude_of_origin").setValue(
            getOriginLong(metadata));
        parameters.parameter("false_easting").setValue(
            getFalseEasting(metadata));
        parameters.parameter("false_northing").setValue(
            getFalseNorthing(metadata));


        return parameters;
      }
      
      /**
                         * 
                         * Lambert Azimuthal Equal Area
                         * 
                         */
      if (name.equalsIgnoreCase("Lambert_Azimuthal_Equal_Area")
                                || code == GeoTiffCoordinateTransformationsCodes.CT_LambertAzimEqualArea) {
                                parameters = mtFactory.getDefaultParameters("Lambert_Azimuthal_Equal_Area");
        
                                parameters.parameter("latitude_of_center").setValue(
                                                getOriginLat(metadata));
                                parameters.parameter("longitude_of_center").setValue(
                                                getOriginLong(metadata));
                                parameters.parameter("false_easting").setValue(
                                                getFalseEasting(metadata));
                                parameters.parameter("false_northing").setValue(
                                                getFalseNorthing(metadata));
        
                                return parameters;
                        }


      /**
       * 
       * New Zealand Map Grid
       * 
       */
      if (name.equalsIgnoreCase("New_Zealand_Map_Grid")
          || code == GeoTiffCoordinateTransformationsCodes.CT_NewZealandMapGrid) {
        parameters = mtFactory
            .getDefaultParameters("New_Zealand_Map_Grid");


        parameters.parameter("latitude_of_origin").setValue(
            getOriginLat(metadata));
        parameters.parameter("central_meridian").setValue(
            getOriginLong(metadata));
        parameters.parameter("false_easting").setValue(
            getFalseEasting(metadata));
        parameters.parameter("false_northing").setValue(
            getFalseNorthing(metadata));


        return parameters;
      }
      
      /**
       * 
       * World Van der Grinten I
       * 
       */
      if (name.equalsIgnoreCase("World_Van_der_Grinten_I")
          || code == GeoTiffCoordinateTransformationsCodes.CT_VanDerGrinten) {
        parameters = mtFactory
            .getDefaultParameters("World_Van_der_Grinten_I");


        parameters.parameter("central_meridian").setValue(
            getOriginLong(metadata));
        parameters.parameter("false_easting").setValue(
            getFalseEasting(metadata));
        parameters.parameter("false_northing").setValue(
            getFalseNorthing(metadata));


        return parameters;
      }

View Full Code Here


    /** Step 2: Write grid coverage out to temp file */
    final GridCoverageWriter writer = new ArcGridWriter(wf);


    // setting write parameters
    ParameterValueGroup params;
    params = writer.getFormat().getWriteParameters();
    params.parameter("GRASS").setValue(true);
    final ArcGridWriteParams wp = new ArcGridWriteParams();
    wp.setSourceBands(new int[] { 0 });
    params.parameter(
        AbstractGridFormat.GEOTOOLS_WRITE_PARAMS.getName().toString())
        .setValue(wp);
    // params.parameter("compressed").setValue(false);
    GeneralParameterValue[] gpv = {
        params.parameter("GRASS"),
        params.parameter(AbstractGridFormat.GEOTOOLS_WRITE_PARAMS
            .getName().toString()) };
    writer.write(gc1, gpv);
    writer.dispose();


    /** Step 3: Read the just written coverage */

View Full Code Here


    /** Step 2: Write grid coverage out to temp file */
    final GridCoverageWriter writer = new ArcGridWriter(wf);


    // setting write parameters
    ParameterValueGroup params;
    params = writer.getFormat().getWriteParameters();
    params.parameter("GRASS").setValue(false);
    final ArcGridWriteParams wp = new ArcGridWriteParams();
    wp.setSourceBands(new int[] { 0 });
    params.parameter(
        AbstractGridFormat.GEOTOOLS_WRITE_PARAMS.getName().toString())
        .setValue(wp);
    // params.parameter("compressed").setValue(false);
    GeneralParameterValue[] gpv = {
        params.parameter("GRASS"),
        params.parameter(AbstractGridFormat.GEOTOOLS_WRITE_PARAMS
            .getName().toString()) };
    writer.write(gc1, gpv);
    writer.dispose();


    /** Step 3: Read the just written coverage */

View Full Code Here

   */
  private void parseCoordinateProjectionTransform(
      final MapProjection projTransf, final String name,
      GeoTiffIIOMetadataEncoder metadata) {


    final ParameterValueGroup parameters = projTransf.getParameterValues();


    // /////////////////////////////////////////////////////////////////////
    //
    // Transverse Mercator
    //
    // /////////////////////////////////////////////////////////////////////
    if (projTransf instanceof TransverseMercator
        && name.equalsIgnoreCase("transverse_mercator")) {
      // key 3075
      metadata
          .addGeoShortParam(
              GeoTiffPCSCodes.ProjCoordTransGeoKey,
              GeoTiffCoordinateTransformationsCodes.CT_TransverseMercator);
//      metadata.addGeoAscii(GeoTiffPCSCodes.PCSCitationGeoKey, name);


      // params
      metadata.addGeoDoubleParam(GeoTiffPCSCodes.ProjNatOriginLongGeoKey,
          parameters.parameter("central_meridian").doubleValue());
      metadata.addGeoDoubleParam(GeoTiffPCSCodes.ProjNatOriginLatGeoKey,
          parameters.parameter("latitude_of_origin").doubleValue());
      metadata.addGeoDoubleParam(
          GeoTiffPCSCodes.ProjScaleAtNatOriginGeoKey, parameters
              .parameter("scale_factor").doubleValue());
      metadata.addGeoDoubleParam(GeoTiffPCSCodes.ProjFalseEastingGeoKey,
          parameters.parameter("false_easting").doubleValue());
      metadata.addGeoDoubleParam(GeoTiffPCSCodes.ProjFalseNorthingGeoKey,
          parameters.parameter("false_northing").doubleValue());
      return;
    }


    // /////////////////////////////////////////////////////////////////////
    //
    // Mercator_1SP
    // Mercator_2SP
    //
    // /////////////////////////////////////////////////////////////////////
    if (projTransf instanceof Mercator
        && (name.equalsIgnoreCase("mercator_1SP") || name
            .equalsIgnoreCase("Mercator_2SP"))) {
      // key 3075
      metadata.addGeoShortParam(GeoTiffPCSCodes.ProjCoordTransGeoKey,
          GeoTiffCoordinateTransformationsCodes.CT_Mercator);
//      metadata.addGeoAscii(GeoTiffPCSCodes.PCSCitationGeoKey, name);


      // params
      List<GeneralParameterValue> values = parameters.values();
                        for (GeneralParameterValue value : values){
                            if (value instanceof ParameterValue){
                                ParameterValue<?> paramValue = (ParameterValue<?>) value;
                                if (AbstractIdentifiedObject.nameMatches(value.getDescriptor(), "latitude_of_origin")) {
                                    metadata.addGeoDoubleParam(
                                            GeoTiffPCSCodes.ProjNatOriginLatGeoKey,(paramValue).doubleValue());
                                }else if (AbstractIdentifiedObject.nameMatches(value.getDescriptor(), "central_meridian")) {
                                    metadata.addGeoDoubleParam(
                                            GeoTiffPCSCodes.ProjNatOriginLongGeoKey,(paramValue).doubleValue());
                                }else if (AbstractIdentifiedObject.nameMatches(value.getDescriptor(), "scale_factor")) {
                                    metadata.addGeoDoubleParam(
                                            GeoTiffPCSCodes.ProjScaleAtNatOriginGeoKey,(paramValue).doubleValue());
                                }else if (AbstractIdentifiedObject.nameMatches(value.getDescriptor(), "standard_parallel_1")) {
                                    metadata.addGeoDoubleParam(
                                            GeoTiffPCSCodes.ProjStdParallel1GeoKey,(paramValue).doubleValue());
                                }else if (AbstractIdentifiedObject.nameMatches(value.getDescriptor(), "false_easting")) {
                                    metadata.addGeoDoubleParam(
                                            GeoTiffPCSCodes.ProjFalseEastingGeoKey,(paramValue).doubleValue());
                                }else if (AbstractIdentifiedObject.nameMatches(value.getDescriptor(), "false_northing")) {
                                    metadata.addGeoDoubleParam(
                                            GeoTiffPCSCodes.ProjFalseNorthingGeoKey,(paramValue).doubleValue());
                                }
                            }
                        }
                        
      return;
    }


    // /////////////////////////////////////////////////////////////////////
    //
    // Lamber conformal 1sp
    //
    // /////////////////////////////////////////////////////////////////////
    if (projTransf instanceof LambertConformal && name.indexOf("1") != -1) {


      // key 3075
      metadata
          .addGeoShortParam(
              GeoTiffPCSCodes.ProjCoordTransGeoKey,
              GeoTiffCoordinateTransformationsCodes.CT_LambertConfConic_Helmert);
//      metadata.addGeoAscii(GeoTiffPCSCodes.PCSCitationGeoKey, name);


      // params
      metadata.addGeoDoubleParam(GeoTiffPCSCodes.ProjNatOriginLongGeoKey,
          parameters.parameter("central_meridian").doubleValue());
      metadata.addGeoDoubleParam(GeoTiffPCSCodes.ProjNatOriginLatGeoKey,
          parameters.parameter("latitude_of_origin").doubleValue());
      metadata.addGeoDoubleParam(
          GeoTiffPCSCodes.ProjScaleAtNatOriginGeoKey, parameters
              .parameter("scale_factor").doubleValue());
      metadata.addGeoDoubleParam(GeoTiffPCSCodes.ProjFalseEastingGeoKey,
          parameters.parameter("false_easting").doubleValue());
      metadata.addGeoDoubleParam(GeoTiffPCSCodes.ProjFalseNorthingGeoKey,
          parameters.parameter("false_northing").doubleValue());
      return;


    }


    // /////////////////////////////////////////////////////////////////////
    //
    // LAMBERT_CONFORMAL_CONIC_2SP
    // lambert_conformal_conic_2SP_Belgium
    //
    // /////////////////////////////////////////////////////////////////////
    if (projTransf instanceof LambertConformal && name.indexOf("2") != -1) {
      // key 3075
      metadata
          .addGeoShortParam(
              GeoTiffPCSCodes.ProjCoordTransGeoKey,
              GeoTiffCoordinateTransformationsCodes.CT_LambertConfConic_2SP);
//      metadata.addGeoAscii(GeoTiffPCSCodes.PCSCitationGeoKey, name);


      // params
      metadata.addGeoDoubleParam(GeoTiffPCSCodes.ProjNatOriginLongGeoKey,
          parameters.parameter("central_meridian").doubleValue());
      metadata.addGeoDoubleParam(GeoTiffPCSCodes.ProjNatOriginLatGeoKey,
          parameters.parameter("latitude_of_origin").doubleValue());
      metadata.addGeoDoubleParam(GeoTiffPCSCodes.ProjStdParallel1GeoKey,
          parameters.parameter("standard_parallel_1").doubleValue());
      metadata.addGeoDoubleParam(GeoTiffPCSCodes.ProjStdParallel2GeoKey,
          parameters.parameter("standard_parallel_2").doubleValue());
      metadata.addGeoDoubleParam(GeoTiffPCSCodes.ProjFalseEastingGeoKey,
          parameters.parameter("false_easting").doubleValue());
      metadata.addGeoDoubleParam(GeoTiffPCSCodes.ProjFalseNorthingGeoKey,
          parameters.parameter("false_northing").doubleValue());
      return;


    }


    // if (name.equalsIgnoreCase("equidistant_conic")
    // || code == GeoTiffMetadata2CRSAdapter.CT_EquidistantConic) {
    // parameters = mtFactory
    // .getDefaultParameters("equidistant_conic");
    // parameters.parameter("central_meridian").setValue(
    // getOriginLong());
    // parameters.parameter("latitude_of_origin").setValue(
    // getOriginLat());
    // parameters
    // .parameter("standard_parallel_1")
    // .setValue(
    // this
    // .getGeoKeyAsDouble(GeoTiffIIOMetadataDecoder.ProjStdParallel1GeoKey));
    // parameters
    // .parameter("standard_parallel_2")
    // .setValue(
    // this
    // .getGeoKeyAsDouble(GeoTiffIIOMetadataDecoder.ProjStdParallel2GeoKey));
    // parameters.parameter("false_easting").setValue(
    // getFalseEasting());
    // parameters.parameter("false_northing").setValue(
    // getFalseNorthing());
    //
    // return parameters;
    // }


    // /////////////////////////////////////////////////////////////////////
    //
    // stereographic
    //
    // /////////////////////////////////////////////////////////////////////
    if (projTransf instanceof Stereographic
        && name.equalsIgnoreCase("stereographic")) {


      // key 3075
      metadata.addGeoShortParam(GeoTiffPCSCodes.ProjCoordTransGeoKey,
          GeoTiffCoordinateTransformationsCodes.CT_Stereographic);
//      metadata.addGeoAscii(GeoTiffPCSCodes.PCSCitationGeoKey, name);


      // params
      metadata.addGeoDoubleParam(GeoTiffPCSCodes.ProjNatOriginLongGeoKey,
          parameters.parameter("central_meridian").doubleValue());
      metadata.addGeoDoubleParam(GeoTiffPCSCodes.ProjNatOriginLatGeoKey,
          parameters.parameter("latitude_of_origin").doubleValue());
      metadata.addGeoDoubleParam(
          GeoTiffPCSCodes.ProjScaleAtNatOriginGeoKey, parameters
              .parameter("scale_factor").doubleValue());
      metadata.addGeoDoubleParam(GeoTiffPCSCodes.ProjFalseEastingGeoKey,
          parameters.parameter("false_easting").doubleValue());
      metadata.addGeoDoubleParam(GeoTiffPCSCodes.ProjFalseNorthingGeoKey,
          parameters.parameter("false_northing").doubleValue());
      return;


    }


    // /////////////////////////////////////////////////////////////////////
    //
    // polar_stereographic
    //
    // /////////////////////////////////////////////////////////////////////
    if (projTransf instanceof PolarStereographic
        && name.equalsIgnoreCase("polar_stereographic")) {
      // key 3075
      metadata
          .addGeoShortParam(
              GeoTiffPCSCodes.ProjCoordTransGeoKey,
              GeoTiffCoordinateTransformationsCodes.CT_PolarStereographic);
//      metadata.addGeoAscii(GeoTiffPCSCodes.PCSCitationGeoKey, name);


      // params
      metadata.addGeoDoubleParam(GeoTiffPCSCodes.ProjNatOriginLongGeoKey,
          parameters.parameter("central_meridian").doubleValue());
      metadata.addGeoDoubleParam(
          GeoTiffPCSCodes.ProjStraightVertPoleLongGeoKey, parameters
              .parameter("latitude_of_origin").doubleValue());
      metadata.addGeoDoubleParam(
          GeoTiffPCSCodes.ProjScaleAtNatOriginGeoKey, parameters
              .parameter("scale_factor").doubleValue());
      metadata.addGeoDoubleParam(GeoTiffPCSCodes.ProjFalseEastingGeoKey,
          parameters.parameter("false_easting").doubleValue());
      metadata.addGeoDoubleParam(GeoTiffPCSCodes.ProjFalseNorthingGeoKey,
          parameters.parameter("false_northing").doubleValue());
      return;


    }
    
    // /////////////////////////////////////////////////////////////////////
    //
    // Oblique_Stereographic
    //
    // /////////////////////////////////////////////////////////////////////
    if(projTransf instanceof ObliqueStereographic 
        && name.equalsIgnoreCase("Oblique_Stereographic")) {
       metadata.addGeoShortParam(
           GeoTiffPCSCodes.ProjCoordTransGeoKey,
           GeoTiffCoordinateTransformationsCodes.CT_ObliqueStereographic);
//       metadata.addGeoAscii(GeoTiffPCSCodes.PCSCitationGeoKey, name);
       
       // params      
       metadata.addGeoDoubleParam(GeoTiffPCSCodes.ProjNatOriginLongGeoKey,
           parameters.parameter("central_meridian").doubleValue());
       metadata.addGeoDoubleParam(GeoTiffPCSCodes.ProjNatOriginLatGeoKey,
           parameters.parameter("latitude_of_origin").doubleValue());
       metadata.addGeoDoubleParam(
           GeoTiffPCSCodes.ProjScaleAtNatOriginGeoKey, parameters
               .parameter("scale_factor").doubleValue());
       metadata.addGeoDoubleParam(GeoTiffPCSCodes.ProjFalseEastingGeoKey,
           parameters.parameter("false_easting").doubleValue());
       metadata.addGeoDoubleParam(GeoTiffPCSCodes.ProjFalseNorthingGeoKey,
           parameters.parameter("false_northing").doubleValue());
       return;
     }
             
    // /////////////////////////////////////////////////////////////////////
    //
    // Oblique Mercator
    //
    // /////////////////////////////////////////////////////////////////////
    if (projTransf instanceof ObliqueMercator
        && (name.equalsIgnoreCase("oblique_mercator") || name
            .equalsIgnoreCase("hotine_oblique_mercator"))) {


      // key 3075
      metadata.addGeoShortParam(GeoTiffPCSCodes.ProjCoordTransGeoKey,
          GeoTiffCoordinateTransformationsCodes.CT_ObliqueMercator);
//      metadata.addGeoAscii(GeoTiffPCSCodes.PCSCitationGeoKey, name);


      // params
      metadata.addGeoDoubleParam(GeoTiffPCSCodes.ProjCenterLongGeoKey,
          parameters.parameter("longitude_of_center").doubleValue());
      metadata.addGeoDoubleParam(GeoTiffPCSCodes.ProjCenterLatGeoKey,
          parameters.parameter("latitude_of_center").doubleValue());
      metadata.addGeoDoubleParam(GeoTiffPCSCodes.ProjScaleAtCenterGeoKey,
          parameters.parameter("scale_factor").doubleValue());
      metadata.addGeoDoubleParam(GeoTiffPCSCodes.ProjFalseEastingGeoKey,
          parameters.parameter("false_easting").doubleValue());
      metadata.addGeoDoubleParam(GeoTiffPCSCodes.ProjAzimuthAngleGeoKey,
          parameters.parameter("azimuth").doubleValue());
      metadata.addGeoDoubleParam(GeoTiffPCSCodes.ProjFalseNorthingGeoKey,
          parameters.parameter("false_northing").doubleValue());
      // rectified grid angle???
      return;


    }
    // /////////////////////////////////////////////////////////////////////
    //
    // albers_Conic_Equal_Area
    //
    // /////////////////////////////////////////////////////////////////////
    if (projTransf instanceof AlbersEqualArea
        && name.equalsIgnoreCase("albers_Conic_Equal_Area")) {


      // key 3075
      metadata.addGeoShortParam(GeoTiffPCSCodes.ProjCoordTransGeoKey,
          GeoTiffCoordinateTransformationsCodes.CT_AlbersEqualArea);
//      metadata.addGeoAscii(GeoTiffPCSCodes.PCSCitationGeoKey, name);


      // params
      metadata.addGeoDoubleParam(GeoTiffPCSCodes.ProjNatOriginLongGeoKey,
          parameters.parameter("longitude_of_center").doubleValue());
      metadata.addGeoDoubleParam(GeoTiffPCSCodes.ProjNatOriginLatGeoKey,
          parameters.parameter("latitude_of_center").doubleValue());
      metadata.addGeoDoubleParam(GeoTiffPCSCodes.ProjFalseEastingGeoKey,
          parameters.parameter("false_easting").doubleValue());
      metadata.addGeoDoubleParam(GeoTiffPCSCodes.ProjFalseNorthingGeoKey,
          parameters.parameter("false_northing").doubleValue());
      metadata.addGeoDoubleParam(GeoTiffPCSCodes.ProjStdParallel1GeoKey,
          parameters.parameter("standard_parallel_1").doubleValue());
      metadata.addGeoDoubleParam(GeoTiffPCSCodes.ProjStdParallel2GeoKey,
          parameters.parameter("standard_parallel_2").doubleValue());
      // rectified grid angle???
      return;


    }


    // /////////////////////////////////////////////////////////////////////
    //
    // Orthographic
    //
    // /////////////////////////////////////////////////////////////////////
    if (projTransf instanceof Orthographic
        && name.equalsIgnoreCase("Orthographic")) {


      // key 3075
      metadata.addGeoShortParam(GeoTiffPCSCodes.ProjCoordTransGeoKey,
          GeoTiffCoordinateTransformationsCodes.CT_Orthographic);
//      metadata.addGeoAscii(GeoTiffPCSCodes.PCSCitationGeoKey, name);


      // params
      metadata.addGeoDoubleParam(GeoTiffPCSCodes.ProjCenterLongGeoKey,
          parameters.parameter("central_meridian").doubleValue());
      metadata.addGeoDoubleParam(GeoTiffPCSCodes.ProjCenterLongGeoKey,
          parameters.parameter("latitude_of_origin").doubleValue());
      metadata.addGeoDoubleParam(GeoTiffPCSCodes.ProjFalseEastingGeoKey,
          parameters.parameter("false_easting").doubleValue());
      metadata.addGeoDoubleParam(GeoTiffPCSCodes.ProjFalseNorthingGeoKey,
          parameters.parameter("false_northing").doubleValue());
      return;
    }
    
    // /////////////////////////////////////////////////////////////////////
                //
                // Lambert Azimuthal Equal Area
                //
                // /////////////////////////////////////////////////////////////////////
    if (projTransf instanceof LambertAzimuthalEqualArea
                        && name.equalsIgnoreCase("Lambert_Azimuthal_Equal_Area")) {


                // key 3075
                    metadata.addGeoShortParam(GeoTiffPCSCodes.ProjCoordTransGeoKey,
                                    GeoTiffCoordinateTransformationsCodes.CT_LambertAzimEqualArea);
//                    metadata.addGeoAscii(GeoTiffPCSCodes.PCSCitationGeoKey, name);
    
                    // params
                    metadata.addGeoDoubleParam(GeoTiffPCSCodes.ProjCenterLatGeoKey,
                                    parameters.parameter("latitude_of_center").doubleValue());
                    metadata.addGeoDoubleParam(GeoTiffPCSCodes.ProjCenterLongGeoKey,
                                    parameters.parameter("longitude_of_center").doubleValue());
                    metadata.addGeoDoubleParam(GeoTiffPCSCodes.ProjFalseEastingGeoKey,
                                    parameters.parameter("false_easting").doubleValue());
                    metadata.addGeoDoubleParam(GeoTiffPCSCodes.ProjFalseNorthingGeoKey,
                                    parameters.parameter("false_northing").doubleValue());
                    return;
                }
    
          // /////////////////////////////////////////////////////////////////////
                //
                // Van der Grinten
                //
                // /////////////////////////////////////////////////////////////////////
                if (projTransf instanceof WorldVanDerGrintenI
                        && name.equalsIgnoreCase("World_Van_der_Grinten_I")) {


                    // key 3075
                    metadata.addGeoShortParam(GeoTiffPCSCodes.ProjCoordTransGeoKey,GeoTiffCoordinateTransformationsCodes.CT_VanDerGrinten);
//                    metadata.addGeoAscii(GeoTiffPCSCodes.PCSCitationGeoKey, name);
    
                    // params
                    metadata.addGeoDoubleParam(GeoTiffPCSCodes.ProjCenterLongGeoKey,parameters.parameter("central_meridian").doubleValue());
                    metadata.addGeoDoubleParam(GeoTiffPCSCodes.ProjFalseEastingGeoKey,parameters.parameter("false_easting").doubleValue());
                    metadata.addGeoDoubleParam(GeoTiffPCSCodes.ProjFalseNorthingGeoKey,parameters.parameter("false_northing").doubleValue());
                    return;
                }
    
                // we did not support this one
                throw new IllegalArgumentException("Unable to map projection"+projTransf.getName());

View Full Code Here

    }


    private void setDefaultParameterValues() {
        
        // get the read parameters for this format plus the ones for the basic format and set them to the default
      final ParameterValueGroup readParams = this.rasterManager.parentReader.getFormat().getReadParameters();
      if (readParams == null) {
        if(LOGGER.isLoggable(Level.FINER))
          LOGGER.finer("No default values for the read parameters!");
        return;
      }
      final List<GeneralParameterDescriptor> parametersDescriptors = readParams.getDescriptor().descriptors();
      for(GeneralParameterDescriptor descriptor:parametersDescriptors){
        
        // we canc get the default vale only with the ParameterDescriptor class
        if(!(descriptor instanceof ParameterDescriptor))
          continue;

View Full Code Here

        prepare();
    }


    @SuppressWarnings({ "unchecked", "deprecation" })
  private void setDefaultParameterValues() {
      final ParameterValueGroup readParams = this.rasterManager.parent.getFormat().getReadParameters();
      if(readParams==null){
        if(LOGGER.isLoggable(Level.FINE))
          LOGGER.fine("No default values for the read parameters!");
        return;
      }
      final List<GeneralParameterDescriptor> parametersDescriptors = readParams.getDescriptor().descriptors();
      for(GeneralParameterDescriptor descriptor:parametersDescriptors){
        
        // we canc get the default vale only with the ParameterDescriptor class
        if(!(descriptor instanceof ParameterDescriptor))
          continue;

View Full Code Here

        }
            
        MapProjection mapProjection = CRS.getMapProjection(renderingEnvelope
                .getCoordinateReferenceSystem());
        if(mapProjection instanceof LambertConformal || mapProjection instanceof EquidistantConic) {
            ParameterValueGroup params = mapProjection.getParameterValues();
            double centralMeridian = params.parameter(
                    AbstractProvider.CENTRAL_MERIDIAN.getName().getCode()).doubleValue();
            double minLat , maxLat;


            double latitudeOrigin;
            if (mapProjection instanceof LambertConformal1SP) {
                latitudeOrigin = params.parameter(
                        AbstractProvider.LATITUDE_OF_ORIGIN.getName().getCode()).doubleValue();
            } else {
                double stdParallel1 = params.parameter(
                        AbstractProvider.STANDARD_PARALLEL_1.getName().getCode()).doubleValue();
                double stdParallel2 = params.parameter(
                        AbstractProvider.STANDARD_PARALLEL_2.getName().getCode()).doubleValue();
                latitudeOrigin = (stdParallel1 + stdParallel2) / 2;
               
            }
            if(latitudeOrigin > 0) {

View Full Code Here

        }
        if (count >= check.getMaximumOccurs()) {
            throw new InvalidParameterCardinalityException(Errors.format(
                      ErrorKeys.TOO_MANY_OCCURENCES_$2, name, count), name);
        }
        final ParameterValueGroup value = ((ParameterDescriptorGroup) check).createValue();
        values.add(value);
        return value;
    }

View Full Code Here

         * Now format all groups deferred to the end of this table.
         * Most of the time, there is no such group.
         */
        if (deferredGroups != null) {
            for (final Object element : deferredGroups) {
                final ParameterValueGroup value;
                final ParameterDescriptorGroup descriptor;
                if (element instanceof ParameterValueGroup) {
                    value = (ParameterValueGroup) element;
                    descriptor = value.getDescriptor();
                } else {
                    value = null;
                    descriptor = (ParameterDescriptorGroup) element;
                }
                out.write(lineSeparator);

View Full Code Here

    @Test
    public void testHardCoded() throws ParseException {
        final Parser parser = new Parser();
        String              wkt1, wkt2;
        DefaultProjectedCRS crs1, crs2;
        ParameterValueGroup param;
        /*
         * First, rather simple Mercator projection.
         * Uses standard units and axis order.
         */
        wkt1 = "PROJCS[\"Mercator test\",\n"                             +
               "  GEOGCS[\"WGS84\",\n"                                   +
               "    DATUM[\"WGS84\",\n"                                  +
               "      SPHEROID[\"WGS84\", 6378137.0, 298.257223563]],\n" +
               "    PRIMEM[\"Greenwich\", 0.0],\n"                       +
               "    UNIT[\"degree\", 0.017453292519943295],\n"           +
               "    AXIS[\"Longitude\", EAST],\n"                        +
               "    AXIS[\"Latitude\", NORTH]],\n"                       +
               "  PROJECTION[\"Mercator_1SP\"],\n"                       +
               "  PARAMETER[\"central_meridian\", -20.0],\n"             +
               "  PARAMETER[\"scale_factor\", 1.0],\n"                   +
               "  PARAMETER[\"false_easting\", 500000.0],\n"             +
               "  PARAMETER[\"false_northing\", 0.0],\n"                 +
               "  UNIT[\"m\", 1.0],\n"                                   +
               "  AXIS[\"x\", EAST],\n"                                  +
               "  AXIS[\"y\", NORTH]]\n";
        assertTrue(Symbols.DEFAULT.containsAxis(wkt1));
        crs1  = (DefaultProjectedCRS) parser.parseObject(wkt1);
        wkt2  = parser.format(crs1);
        crs2  = (DefaultProjectedCRS) parser.parseObject(wkt2);
        param = crs1.getConversionFromBase().getParameterValues();
        assertEquals(crs1, crs2);
        assertEquals("Mercator_1SP", crs1.getConversionFromBase().getMethod().getName().getCode());
        assertTrue(crs1.getConversionFromBase().getMathTransform().toWKT().startsWith("PARAM_MT[\"Mercator_1SP\""));
        assertFalse (wkt2.contains("semi_major"));
        assertFalse (wkt2.contains("semi_minor"));
        assertEquals("semi_major",   6378137.0, param.parameter("semi_major"      ).doubleValue(), 1E-4);
        assertEquals("semi_minor",   6356752.3, param.parameter("semi_minor"      ).doubleValue(), 1E-1);
        assertEquals("central_meridian", -20.0, param.parameter("central_meridian").doubleValue(), 1E-8);
        assertEquals("scale_factor",       1.0, param.parameter("scale_factor"    ).doubleValue(), 1E-8);
        assertEquals("false_easting", 500000.0, param.parameter("false_easting"   ).doubleValue(), 1E-4);
        assertEquals("false_northing",     0.0, param.parameter("false_northing"  ).doubleValue(), 1E-4);
        /*
         * Same Mercator projection as above, but
         * switch longitude and latitude axis.
         */
        wkt1 = "PROJCS[\"Mercator test\",\n"                             +
               "  GEOGCS[\"WGS84\",\n"                                   +
               "    DATUM[\"WGS84\",\n"                                  +
               "      SPHEROID[\"WGS84\", 6378137.0, 298.257223563]],\n" +
               "    PRIMEM[\"Greenwich\", 0.0],\n"                       +
               "    UNIT[\"degree\", 0.017453292519943295],\n"           +
               "    AXIS[\"Latitude\", NORTH],\n"                        +
               "    AXIS[\"Longitude\", EAST]],\n"                       +
               "  PROJECTION[\"Mercator_1SP\"],\n"                       +
               "  PARAMETER[\"central_meridian\", -20.0],\n"             +
               "  PARAMETER[\"scale_factor\", 1.0],\n"                   +
               "  PARAMETER[\"false_easting\", 500000.0],\n"             +
               "  PARAMETER[\"false_northing\", 0.0],\n"                 +
               "  UNIT[\"m\", 1.0],\n"                                   +
               "  AXIS[\"x\", EAST],\n"                                  +
               "  AXIS[\"y\", NORTH]]\n";
        assertTrue(Symbols.DEFAULT.containsAxis(wkt1));
        crs1  = (DefaultProjectedCRS) parser.parseObject(wkt1);
        wkt2  = parser.format(crs1);
        crs2  = (DefaultProjectedCRS) parser.parseObject(wkt2);
        param = crs1.getConversionFromBase().getParameterValues();
        assertEquals(crs1, crs2);
        assertEquals("Mercator_1SP", crs1.getConversionFromBase().getMethod().getName().getCode());
        assertTrue(crs1.getConversionFromBase().getMathTransform().toWKT().startsWith("CONCAT_MT[PARAM_MT["));
        assertFalse (wkt2.contains("semi_major"));
        assertFalse (wkt2.contains("semi_minor"));
        assertEquals("semi_major",   6378137.0, param.parameter("semi_major"      ).doubleValue(), 1E-4);
        assertEquals("semi_minor",   6356752.3, param.parameter("semi_minor"      ).doubleValue(), 1E-1);
        assertEquals("central_meridian", -20.0, param.parameter("central_meridian").doubleValue(), 1E-8);
        assertEquals("scale_factor",       1.0, param.parameter("scale_factor"    ).doubleValue(), 1E-8);
        assertEquals("false_easting", 500000.0, param.parameter("false_easting"   ).doubleValue(), 1E-4);
        assertEquals("false_northing",     0.0, param.parameter("false_northing"  ).doubleValue(), 1E-4);
        /*
         * Try an other projection (Transverse Mercator).
         */
        wkt1 = "PROJCS[\"OSGB 1936 / British National Grid\",\n"                                          +
               "  GEOGCS[\"OSGB 1936\",\n"                                                                +
               "    DATUM[\"OSGB_1936\",\n"                                                               +
               "      SPHEROID[\"Airy 1830\", 6377563.396, 299.3249646, AUTHORITY[\"EPSG\",\"7001\"]],\n" +
               "      TOWGS84[375.0, -111.0, 431.0, 0.0, 0.0, 0.0, 0.0],\n"                               +
               "      AUTHORITY[\"EPSG\",\"6277\"]],\n"                                                   +
               "    PRIMEM[\"Greenwich\",0.0, AUTHORITY[\"EPSG\",\"8901\"]],\n"                           +
               "    UNIT[\"DMSH\",0.0174532925199433, AUTHORITY[\"EPSG\",\"9108\"]],\n"                   +
               "    AXIS[\"Lat\",NORTH],AXIS[\"Long\",EAST], AUTHORITY[\"EPSG\",\"4277\"]],\n"            +
               "  PROJECTION[\"Transverse_Mercator\"],\n"                                                 +
               "  PARAMETER[\"latitude_of_origin\", 49.0],\n"                                             +
               "  PARAMETER[\"central_meridian\", -2.0],\n"                                               +
               "  PARAMETER[\"scale_factor\", 0.999601272],\n"                                            +
               "  PARAMETER[\"false_easting\", 400000.0],\n"                                              +
               "  PARAMETER[\"false_northing\", -100000.0],\n"                                            +
               "  UNIT[\"metre\", 1.0, AUTHORITY[\"EPSG\",\"9001\"]],\n"                                  +
               "  AXIS[\"E\",EAST],\n"                                                                    +
               "  AXIS[\"N\",NORTH],\n"                                                                   +
               "  AUTHORITY[\"EPSG\",\"27700\"]]\n";
        assertTrue(Symbols.DEFAULT.containsAxis(wkt1));
        crs1  = (DefaultProjectedCRS) parser.parseObject(wkt1);
        wkt2  = parser.format(crs1);
        crs2  = (DefaultProjectedCRS) parser.parseObject(wkt2);
        param = crs1.getConversionFromBase().getParameterValues();
        assertEquals(crs1, crs2);
        assertFalse (wkt2.contains("semi_major"));
        assertFalse (wkt2.contains("semi_minor"));
        assertEquals("Transverse_Mercator", crs1.getConversionFromBase().getMethod().getName().getCode());
        assertEquals("semi_major",   6377563.396, param.parameter("semi_major"        ).doubleValue(), 1E-4);
        assertEquals("semi_minor",   6356256.909, param.parameter("semi_minor"        ).doubleValue(), 1E-3);
        assertEquals("latitude_of_origin",  49.0, param.parameter("latitude_of_origin").doubleValue(), 1E-8);
        assertEquals("central_meridian",    -2.0, param.parameter("central_meridian"  ).doubleValue(), 1E-8);
        assertEquals("scale_factor",      0.9996, param.parameter("scale_factor"      ).doubleValue(), 1E-5);
        assertEquals("false_easting",   400000.0, param.parameter("false_easting"     ).doubleValue(), 1E-4);
        assertEquals("false_northing", -100000.0, param.parameter("false_northing"    ).doubleValue(), 1E-4);
        /*
         * Try a projection with feet units.
         */
        wkt1 = "PROJCS[\"TransverseMercator\",\n"                     +
               "  GEOGCS[\"Sphere\",\n"                               +
               "    DATUM[\"Sphere\",\n"                              +
               "      SPHEROID[\"Sphere\", 6370997.0, 0.0],\n"        +
               "      TOWGS84[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]],\n" +
               "    PRIMEM[\"Greenwich\", 0.0],\n"                    +
               "    UNIT[\"degree\", 0.017453292519943295],\n"        +
               "    AXIS[\"Longitude\", EAST],\n"                     +
               "    AXIS[\"Latitude\", NORTH]],\n"                    +
               "  PROJECTION[\"Transverse_Mercator\",\n"              +
               "    AUTHORITY[\"OGC\",\"Transverse_Mercator\"]],\n"   +
               "  PARAMETER[\"central_meridian\", 170.0],\n"          +
               "  PARAMETER[\"latitude_of_origin\", 50.0],\n"         +
               "  PARAMETER[\"scale_factor\", 0.95],\n"               +
               "  PARAMETER[\"false_easting\", 0.0],\n"               +
               "  PARAMETER[\"false_northing\", 0.0],\n"              +
               "  UNIT[\"feet\", 0.304800609601219],\n"               +
               "  AXIS[\"x\", EAST],\n"                               +
               "  AXIS[\"y\", NORTH]]\n";
        assertTrue(Symbols.DEFAULT.containsAxis(wkt1));
        crs1  = (DefaultProjectedCRS) parser.parseObject(wkt1);
        wkt2  = parser.format(crs1);
        crs2  = (DefaultProjectedCRS) parser.parseObject(wkt2);
        param = crs1.getConversionFromBase().getParameterValues();
        assertEquals(crs1, crs2);
        assertFalse (wkt2.contains("semi_major"));
        assertFalse (wkt2.contains("semi_minor"));
        assertEquals("Transverse_Mercator", crs1.getConversionFromBase().getMethod().getName().getCode());
        assertEquals("semi_major",     6370997.0, param.parameter("semi_major"        ).doubleValue(), 1E-5);
        assertEquals("semi_minor",     6370997.0, param.parameter("semi_minor"        ).doubleValue(), 1E-5);
        assertEquals("latitude_of_origin",  50.0, param.parameter("latitude_of_origin").doubleValue(), 1E-8);
        assertEquals("central_meridian",   170.0, param.parameter("central_meridian"  ).doubleValue(), 1E-8);
        assertEquals("scale_factor",        0.95, param.parameter("scale_factor"      ).doubleValue(), 1E-8);
        assertEquals("false_easting",        0.0, param.parameter("false_easting"     ).doubleValue(), 1E-8);
        assertEquals("false_northing",       0.0, param.parameter("false_northing"    ).doubleValue(), 1E-8);
        /*
         * Try with a number using scientific notation.
         */
        wkt1 = "GEOGCS[\"NAD83 / NFIS Seconds\",DATUM[\"North_American_Datum_1983\",\n" +
               "  SPHEROID[\"GRS 1980\", 6378137, 298.257222101]],\n"                   +

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of org.opengis.parameter.ParameterValueGroup

mil.nga.giat.geowave.raster.stats.HistogramStatistics

org.apache.sis.parameter.DefaultParameterValueGroup

org.apache.sis.parameter.DefaultParameterValueGroupTest

org.apache.sis.parameter.ParameterFormatTest

org.apache.sis.parameter.TensorParametersTest

org.apache.sis.parameter.TensorValuesTest

org.geoserver.catalog.CatalogBuilder

org.geoserver.catalog.CoverageViewReader

org.geoserver.data.test.MockData

org.geoserver.data.util.CoverageStoreUtils

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.