Java CF类代码示例

import ucar.nc2.constants.CF; //导入依赖的package包/类
public IoosSosObservation(CF.FeatureType featureType, TimePeriod samplingTime,
        Map<SensorAsset, ? extends AbstractSensorDataset> sensorDatasetMap,
        Set<OmObservableProperty> phenomena, Envelope envelope,
        HashMap<StationAsset,Point> stationPoints, SetMultimap<SensorAsset,Double> sensorHeights ) {
    super();
    this.featureType = featureType;
    this.samplingTime = samplingTime;
    this.sensorDatasetMap = sensorDatasetMap;
    this.phenomena = phenomena;
    this.envelope = envelope;
    this.stationPoints = stationPoints;
    this.sensorHeights = sensorHeights;

    //process datasets into lookup maps by station
    for (SensorAsset sensor : sensorDatasetMap.keySet()) {
        stationSensors.put(sensor.getStationAsset(), sensor);
    }
}
 

import ucar.nc2.constants.CF; //导入依赖的package包/类
public TimeSeriesSensorDataset( SensorAsset sensor, Double lng, Double lat, Double alt, 
        Map<Time, Map<OmObservableProperty, Map<SubSensor, Value<?>>>> dataValues) {        
    super( CF.FeatureType.timeSeries, sensor, dataValues);
    this.lng = lng;
    this.lat = lat;
    this.alt = alt;
}
 

import ucar.nc2.constants.CF; //导入依赖的package包/类
public AbstractSensorDataset( CF.FeatureType featureType, SensorAsset sensor,
        Map<Time,Map<OmObservableProperty,Map<SubSensor,Value<?>>>> dataValues){
    this.featureType = featureType;
    this.sensor = sensor;
    //make the sensorDataValues unmodifiable, since some data summaries will be made below and we don't want the data changing
    this.dataValues = Collections.unmodifiableMap(dataValues);

    //set times, phenomena, and subsensors
    Set<Time> timeSet = Sets.newHashSet();
    Set<OmObservableProperty> obsPropSet = Sets.newHashSet();
    Set<SubSensor> subSensorSet = Sets.newHashSet();
    for( Entry<Time,Map<OmObservableProperty, Map<SubSensor,Value<?>>>> dataValuesEntry : dataValues.entrySet() ){
        Time time = dataValuesEntry.getKey();
        timeSet.add(time);
        for( Map.Entry<OmObservableProperty, Map<SubSensor,Value<?>>> phenObsEntry : dataValuesEntry.getValue().entrySet() ){
            OmObservableProperty phen = phenObsEntry.getKey();                    
            Set<SubSensor> phenSubSensors = phenObsEntry.getValue().keySet();                
            obsPropSet.add(phen);                
            for (SubSensor subSensor : phenSubSensors) {
                if (subSensor != null) {
                    subSensorSet.add(subSensor);
                }
            }                    
        }
    }

    List<Time> timeList = Lists.newArrayList(timeSet);
    Collections.sort(timeList);
    times = Collections.unmodifiableList(timeList);

    List<OmObservableProperty> obsPropList = Lists.newArrayList(obsPropSet);
    Collections.sort(obsPropList);
    obsProps = Collections.unmodifiableList(obsPropList);

    List<SubSensor> subSensorList = Lists.newArrayList(subSensorSet);
    Collections.sort(subSensorList);
    subSensors = Collections.unmodifiableList(subSensorList);
}
 

import ucar.nc2.constants.CF; //导入依赖的package包/类
private String getNodcTemplateVersion(CF.FeatureType featureType) throws CodedException{
    if (featureType.equals(CF.FeatureType.timeSeries)) {
        return NODCConstants.NODC_TIMESERIES_ORTHOGONAL_TEMPLATE_1_0;
    } else if (featureType.equals(CF.FeatureType.timeSeriesProfile)) {
        return NODCConstants.NODC_TIMESERIESPROFILE_ORTHOGONAL_TEMPLATE_1_0;
    }
    throw new NoApplicableCodeException().withMessage("Feature type " + featureType.name()
            + " is not supported for netCDF output");
}
 

import ucar.nc2.constants.CF; //导入依赖的package包/类
private String getCfRole(CF.FeatureType featureType) throws CodedException {
    if (featureType.equals(CF.FeatureType.timeSeries)) {
        return CF.TIMESERIES_ID;
    } else if (featureType.equals(CF.FeatureType.timeSeriesProfile)) {
        return CF.TIMESERIES_ID;
    } else if (featureType.equals(CF.FeatureType.trajectory) || featureType.equals(CF.FeatureType.trajectoryProfile)) {
        return CF.TRAJECTORY_ID;
    } else {
        throw new NoApplicableCodeException().withMessage("Feature type " + featureType.name()
                + " is not supported for netCDF output");
    }
}
 

import ucar.nc2.constants.CF; //导入依赖的package包/类
private boolean isZPositive(CoordinateAxis1D zAxis) {
    if (zAxis == null)
        return false;
    if (zAxis.getPositive() != null) {
        return zAxis.getPositive().equalsIgnoreCase(CF.POSITIVE_UP);
    }
    if (zAxis.getAxisType() == AxisType.Height)
        return true;
    return zAxis.getAxisType() != AxisType.Pressure;
}
 

import ucar.nc2.constants.CF; //导入依赖的package包/类
public TrajectoryProfileSensorDataset( SensorAsset sensor,  
        Map<Time, Map<OmObservableProperty, Map<SubSensor, Value<?>>>> dataValues) {        
    super( CF.FeatureType.trajectoryProfile, sensor, dataValues);
}
 

import ucar.nc2.constants.CF; //导入依赖的package包/类
public CF.FeatureType getFeatureType() {
    return featureType;
}
 

import ucar.nc2.constants.CF; //导入依赖的package包/类
public TimeSeriesProfileSensorDataset( SensorAsset sensor, Double lng, Double lat, 
        Map<Time, Map<OmObservableProperty, Map<SubSensor, Value<?>>>> dataValues) {        
    super( CF.FeatureType.timeSeriesProfile, sensor, dataValues);
    this.lng = lng;
    this.lat = lat;
}
 

import ucar.nc2.constants.CF; //导入依赖的package包/类
public TrajectorySensorDataset( SensorAsset sensor, Double alt, 
        Map<Time, Map<OmObservableProperty, Map<SubSensor, Value<?>>>> dataValues) {        
    super( CF.FeatureType.trajectory, sensor, dataValues);
    this.alt = alt;
}
 

import ucar.nc2.constants.CF; //导入依赖的package包/类
private static void createSensor(int i, CF.FeatureType featureType, Offering hNetworkOffering, Procedure networkProcedure,
        Offering hStationOffering, Procedure stationProcedure, StationAsset station, SamplingFeature samplingFeature,
        FeatureOfInterest hStationFeature, Point stationPoint, Phenomenon phen,
        OmObservableProperty omObsProp, ObservableProperty obsProp, String unit, ObservationType obsType, ProcedureDescriptionFormat pdf,
        Map<String,Codespace> codespaceCache, Map<String,Unit> unitCache, Session session) throws OwsExceptionReport {
    String phenShortName = getPhenomenonShortId(phen.getId());
    final SimpleIo airTempSimpleIo = new SimpleIo(phenShortName, phen.getId(), unit);
    final SensorAsset sensor = new SensorAsset(TEST, Integer.toString(i), phenShortName);
    final String sensorSml = IoosTestDataSmlGenerator.createSensorSensorMl(sensor.getAssetId(),
            "Test station " + i + " " + phen.getName() + " sensor",
            "Test station " + i + " " + phen.getName() + " sensor",
            "Station number " + i + " " + phen.getName() + " sensor",
            CollectionHelper.list(airTempSimpleIo));

    //TODO switch to manually build System instead of making xml
    //TODO decode xml
    Object decodedXml = CodingHelper.decodeXmlObject(sensorSml);
    org.n52.sos.ogc.sensorML.System sensorSystem = new org.n52.sos.ogc.sensorML.System();
    sensorSystem.setIdentifier(sensor.getAssetId());
    sensorSystem.setParentProcedures(CollectionHelper.list(station.getAssetId()));
    final Procedure sensorProcedure = insertProcedure(sensorSystem, pdf, sensorSml, session);

    Set<ObservationConstellation> obsConsts = new HashSet<ObservationConstellation>();
    Set<ObservationConstellation> sensorObsConsts = new HashSet<ObservationConstellation>();

    // when offering and procedure are same hiddenChild is false, otherwise true
    ObservationConstellation sensorForNetworkOffering = obsConstDAO.checkOrInsertObservationConstellation(
            sensorProcedure, obsProp, hNetworkOffering, true, session);
    obsConsts.add(sensorForNetworkOffering);
    sensorObsConsts.add(sensorForNetworkOffering);

    obsConsts.add(obsConstDAO.checkOrInsertObservationConstellation(stationProcedure,
            obsProp, hNetworkOffering, true, session));
    obsConsts.add(obsConstDAO.checkOrInsertObservationConstellation(networkProcedure,
            obsProp, hNetworkOffering, false, session));

    ObservationConstellation sensorForStationOffering = obsConstDAO.checkOrInsertObservationConstellation(
            sensorProcedure, obsProp, hStationOffering, true, session);
    obsConsts.add(sensorForStationOffering);
    sensorObsConsts.add(sensorForStationOffering);

    obsConsts.add(obsConstDAO.checkOrInsertObservationConstellation(stationProcedure,
            obsProp, hStationOffering, false, session));

    //set measurement types on sesnor obs consts
    for (ObservationConstellation obsConst : sensorObsConsts) {
        obsConst.setObservationType(obsType);
        session.save(obsConst);
    }

    //create OmObservationConstellation for OmObservations
    OmObservationConstellation omObsConst = new OmObservationConstellation();
    omObsConst.setProcedure(sensorSystem);
    omObsConst.setObservableProperty(omObsProp);
    omObsConst.setFeatureOfInterest(samplingFeature);

    //add values
    DateTime obsEndTime = new DateTime(DateTimeZone.UTC).withMillisOfSecond(0).withSecondOfMinute(0).withMinuteOfHour(0);
    if (featureType.equals(CF.FeatureType.timeSeriesProfile)) {
        for (int h = 0; h < NUM_HEIGHTS_PER_PROFILE; h++) {
            Geometry foiGeom = GeomHelper.createLatLngPoint(stationPoint.getY(), stationPoint.getX(), 0 - 5.0 * h);
            String foiId;
            try {
                foiId = IoosSosUtil.createObservationFeatureOfInterestId(station, stationPoint, sensor, stationPoint, foiGeom);
            } catch (UnsupportedGeometryTypeException e) {
                throw new NoApplicableCodeException().causedBy(e);
            }
            SamplingFeature profileFeature = new SamplingFeature(new CodeWithAuthority(foiId));
            profileFeature.setGeometry(foiGeom);
            FeatureOfInterest hProfileFeature = featureOfInterestDAO.checkOrInsertFeatureOfInterest(profileFeature, session);
            insertObservation(sensorObsConsts, omObsConst, obsEndTime, hProfileFeature, unit, codespaceCache, unitCache, session);
        }
    } else {
        //normal time series
        insertObservation(sensorObsConsts, omObsConst, obsEndTime, hStationFeature, unit, codespaceCache, unitCache, session);
    }
}