UnitsFactory.java example

Explorer
openmicroscopy-master
/*
 * ome.formats.model.UnitsFactory
 *
 *------------------------------------------------------------------------------
 * Copyright (C) 2014-2015 University of Dundee & Open Microscopy Environment
 * All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

package ome.formats.model;

import ome.model.units.BigResult;
import ome.units.unit.Unit;
import omero.model.ElectricPotential;
import omero.model.ElectricPotentialI;
import omero.model.Frequency;
import omero.model.FrequencyI;
import omero.model.Length;
import omero.model.LengthI;
import omero.model.Power;
import omero.model.PowerI;
import omero.model.Pressure;
import omero.model.PressureI;
import omero.model.Temperature;
import omero.model.TemperatureI;
import omero.model.Time;
import omero.model.TimeI;
import omero.model.enums.UnitsElectricPotential;
import omero.model.enums.UnitsFrequency;
import omero.model.enums.UnitsLength;
import omero.model.enums.UnitsPower;
import omero.model.enums.UnitsPressure;
import omero.model.enums.UnitsTemperature;
import omero.model.enums.UnitsTime;


/**
 * Utility class to generate and convert unit objects.
 *
 * Be especially careful when using methods which take a string
 * since there are 2 types of enumerations, CODE-based and
 * SYMBOL-based.
 */
public class UnitsFactory {

    //
    // ElectricPotential
    //

  public static ome.xml.model.enums.UnitsElectricPotential
      makeElectricPotentialUnitXML(String unit) {
    return ElectricPotentialI.makeXMLUnit(unit);
  }

  public static ome.units.quantity.ElectricPotential
      makeElectricPotentialXML(double d, String unit) {
    return ElectricPotentialI.makeXMLQuantity(d, unit);
  }

  public static ElectricPotential makeElectricPotential(
      double d, Unit<ome.units.quantity.ElectricPotential> unit) {
    return new ElectricPotentialI(d, unit);
  }

  public static ElectricPotential makeElectricPotential(
      double d, UnitsElectricPotential unit) {
    return new ElectricPotentialI(d, unit);
  }

  /**
   * Convert a Bio-Formats {@link ElectricPotential} to an OMERO
   * ElectricPotential. A null will be returned if the input is null.
   */
  public static ElectricPotential convertElectricPotential(
      ome.units.quantity.ElectricPotential value) {
    if (value == null)
      return null;
    String internal = xmlElectricPotentialEnumToOMERO(value.unit().getSymbol());
    UnitsElectricPotential ul = UnitsElectricPotential.valueOf(internal);
    return new omero.model.ElectricPotentialI(value.value().doubleValue(), ul);
  }

  public static ome.units.quantity.ElectricPotential convertElectricPotential(
      ElectricPotential t) {
    return ElectricPotentialI.convert(t);
  }

  public static ElectricPotential convertElectricPotential(
      ElectricPotential value, Unit<ome.units.quantity.ElectricPotential> ul
  ) throws BigResult {
    return convertElectricPotentialXML(value, ul.getSymbol());
  }

  public static ElectricPotential convertElectricPotentialXML(
      ElectricPotential value, String xml) throws BigResult {
    String omero = xmlElectricPotentialEnumToOMERO(xml);
    return new ElectricPotentialI(value, omero);
  }

  public static String xmlElectricPotentialEnumToOMERO(
      Unit<ome.units.quantity.ElectricPotential> xml) {
    return ome.model.enums.UnitsElectricPotential.bySymbol(
        xml.getSymbol()).toString();
  }

  public static String xmlElectricPotentialEnumToOMERO(String xml) {
    return ome.model.enums.UnitsElectricPotential.bySymbol(xml).toString();
  }

  //
  // Frequency
  //

  public static ome.xml.model.enums.UnitsFrequency makeFrequencyUnitXML(
      String unit) {
    return FrequencyI.makeXMLUnit(unit);
  }

  public static ome.units.quantity.Frequency makeFrequencyXML(
      double d, String unit) {
    return FrequencyI.makeXMLQuantity(d, unit);
  }

  public static Frequency makeFrequency(
      double d, Unit<ome.units.quantity.Frequency> unit) {
    return new FrequencyI(d, unit);
  }

  public static Frequency makeFrequency(double d, UnitsFrequency unit) {
    return new FrequencyI(d, unit);
  }

  /**
   * Convert a Bio-Formats {@link Frequency} to an OMERO Frequency. A
   * null will be returned if the input is null.
   */
  public static Frequency convertFrequency(ome.units.quantity.Frequency value) {
    if (value == null)
      return null;
    String internal = xmlFrequencyEnumToOMERO(value.unit().getSymbol());
    UnitsFrequency ul = UnitsFrequency.valueOf(internal);
    return new omero.model.FrequencyI(value.value().doubleValue(), ul);
  }

  public static ome.units.quantity.Frequency convertFrequency(Frequency t) {
    return FrequencyI.convert(t);
  }

  public static Frequency convertFrequency(
      Frequency value, Unit<ome.units.quantity.Frequency> ul) throws BigResult {
    return convertFrequencyXML(value, ul.getSymbol());
  }

  public static Frequency convertFrequencyXML(Frequency value, String xml)
      throws BigResult {
    String omero = xmlFrequencyEnumToOMERO(xml);
    return new FrequencyI(value, omero);
  }

  public static String xmlFrequencyEnumToOMERO(
      Unit<ome.units.quantity.Frequency> xml) {
    return ome.model.enums.UnitsFrequency.bySymbol(xml.getSymbol()).toString();
  }

  public static String xmlFrequencyEnumToOMERO(String xml) {
    return ome.model.enums.UnitsFrequency.bySymbol(xml).toString();
  }

  //
  // Length
  //

  public static ome.xml.model.enums.UnitsLength makeLengthUnitXML(String unit) {
    return LengthI.makeXMLUnit(unit);
  }

  public static ome.units.quantity.Length makeLengthXML(double d, String unit) {
    return LengthI.makeXMLQuantity(d, unit);
  }

  public static Length makeLength(
      double d, Unit<ome.units.quantity.Length> unit) {
    return new LengthI(d, unit);
  }

  public static Length makeLength(double d, UnitsLength unit) {
    return new LengthI(d, unit);
  }

  /**
   * Convert a Bio-Formats {@link Length} to an OMERO Length. A null will be
   * returned if the input is null.
   */
  public static Length convertLength(ome.units.quantity.Length value) {
    if (value == null)
      return null;
    String internal = xmlLengthEnumToOMERO(value.unit().getSymbol());
    UnitsLength ul = UnitsLength.valueOf(internal);
    return new omero.model.LengthI(value.value().doubleValue(), ul);
  }

  public static ome.units.quantity.Length convertLength(Length t) {
    return LengthI.convert(t);
  }

  public static Length convertLength(
      Length value, Unit<ome.units.quantity.Length> ul) throws BigResult {
    return convertLengthXML(value, ul.getSymbol());
  }

  public static Length convertLengthXML(Length value, String xml)
      throws BigResult {
    String omero = xmlLengthEnumToOMERO(xml);
    return new LengthI(value, omero);
  }

  public static String xmlLengthEnumToOMERO(
      Unit<ome.units.quantity.Length> xml) {
    return ome.model.enums.UnitsLength.bySymbol(xml.getSymbol()).toString();
  }

  public static String xmlLengthEnumToOMERO(String xml) {
    return ome.model.enums.UnitsLength.bySymbol(xml).toString();
  }

  //
  // Power
  //

  public static ome.xml.model.enums.UnitsPower makePowerUnitXML(String unit) {
    return PowerI.makeXMLUnit(unit);
  }

  public static ome.units.quantity.Power makePowerXML(double d, String unit) {
    return PowerI.makeXMLQuantity(d, unit);
  }

  public static Power makePower(
      double d, Unit<ome.units.quantity.Power> unit) {
    return new PowerI(d, unit);
  }

  public static Power makePower(double d, UnitsPower unit) {
    return new PowerI(d, unit);
  }

  /**
   * Convert a Bio-Formats {@link Power} to an OMERO Power. A null
   * will be returned if the input is null.
   */
  public static Power convertPower(ome.units.quantity.Power value) {
    if (value == null)
      return null;
    String internal = xmlPowerEnumToOMERO(value.unit().getSymbol());
    UnitsPower ul = UnitsPower.valueOf(internal);
    return new omero.model.PowerI(value.value().doubleValue(), ul);
  }

  public static ome.units.quantity.Power convertPower(Power t) {
    return PowerI.convert(t);
  }

  public static Power convertPower(
      Power value, Unit<ome.units.quantity.Power> ul) throws BigResult {
    return convertPowerXML(value, ul.getSymbol());
  }

  public static Power convertPowerXML(Power value, String xml)
    throws BigResult {
    String omero = xmlPowerEnumToOMERO(xml);
    return new PowerI(value, omero);
  }

  public static String xmlPowerEnumToOMERO(Unit<ome.units.quantity.Power> xml) {
    return ome.model.enums.UnitsPower.bySymbol(xml.getSymbol()).toString();
  }

  public static String xmlPowerEnumToOMERO(String xml) {
    return ome.model.enums.UnitsPower.bySymbol(xml).toString();
  }

    //
    // Pressure
    //

  public static ome.xml.model.enums.UnitsPressure makePressureUnitXML(
      String unit) {
    return PressureI.makeXMLUnit(unit);
  }

  public static ome.units.quantity.Pressure makePressureXML(
      double d, String unit) {
    return PressureI.makeXMLQuantity(d, unit);
  }

  public static Pressure makePressure(
      double d, Unit<ome.units.quantity.Pressure> unit) {
    return new PressureI(d, unit);
  }

  public static Pressure makePressure(double d, UnitsPressure unit) {
    return new PressureI(d, unit);
  }

  /**
   * Convert a Bio-Formats {@link Pressure} to an OMERO Pressure. A null will be
   * returned if the input is null.
   */
  public static Pressure convertPressure(ome.units.quantity.Pressure value) {
    if (value == null)
      return null;
    String internal = xmlPressureEnumToOMERO(value.unit().getSymbol());
    UnitsPressure ul = UnitsPressure.valueOf(internal);
    return new omero.model.PressureI(value.value().doubleValue(), ul);
  }

  public static ome.units.quantity.Pressure convertPressure(Pressure t) {
    return PressureI.convert(t);
  }

  public static Pressure convertPressure(
      Pressure value, Unit<ome.units.quantity.Pressure> ul) throws BigResult {
    return convertPressureXML(value, ul.getSymbol());
  }

  public static Pressure convertPressureXML(Pressure value, String xml)
      throws BigResult {
    String omero = xmlPressureEnumToOMERO(xml);
    return new PressureI(value, omero);
  }

  public static String xmlPressureEnumToOMERO(
      Unit<ome.units.quantity.Pressure> xml) {
    return ome.model.enums.UnitsPressure.bySymbol(xml.getSymbol()).toString();
  }

  public static String xmlPressureEnumToOMERO(String xml) {
    return ome.model.enums.UnitsPressure.bySymbol(xml).toString();
  }

  //
  // Temperature
  //

  public static ome.xml.model.enums.UnitsTemperature makeTemperatureUnitXML(
      String unit) {
    return TemperatureI.makeXMLUnit(unit);
  }

  public static ome.units.quantity.Temperature makeTemperatureXML(
      double d, String unit) {
    return TemperatureI.makeXMLQuantity(d, unit);
  }

  public static Temperature makeTemperature(
      double d, Unit<ome.units.quantity.Temperature> unit) {
    return new TemperatureI(d, unit);
  }

  public static Temperature makeTemperature(double d, UnitsTemperature unit) {
    return new TemperatureI(d, unit);
  }

  /**
   * Convert a Bio-Formats {@link Temperature} to an OMERO
   * Temperature. A null will be returned if the input is null.
   */
  public static Temperature convertTemperature(
      ome.units.quantity.Temperature value) {
    if (value == null)
      return null;
    String internal = xmlTemperatureEnumToOMERO(value.unit().getSymbol());
    UnitsTemperature ul = UnitsTemperature.valueOf(internal);
    return new omero.model.TemperatureI(value.value().doubleValue(), ul);
  }

  public static ome.units.quantity.Temperature convertTemperature(
      Temperature t) {
    return TemperatureI.convert(t);
  }

  public static Temperature convertTemperature(
      Temperature value, Unit<ome.units.quantity.Temperature> ul)
      throws BigResult {
    return convertTemperatureXML(value, ul.getSymbol());
  }

  public static Temperature convertTemperatureXML(
      Temperature value, String xml) throws BigResult {
    String omero = xmlTemperatureEnumToOMERO(xml);
    return new TemperatureI(value, omero);
  }

  public static String xmlTemperatureEnumToOMERO(
      Unit<ome.units.quantity.Temperature> xml) {
    return ome.model.enums.UnitsTemperature.bySymbol(
        xml.getSymbol()).toString();
  }

  public static String xmlTemperatureEnumToOMERO(String xml) {
    return ome.model.enums.UnitsTemperature.bySymbol(xml).toString();
  }

  //
  // Time
  //

  public static ome.xml.model.enums.UnitsTime makeTimeUnitXML(String unit) {
    return TimeI.makeXMLUnit(unit);
  }

  public static ome.units.quantity.Time makeTimeXML(double d, String unit) {
    return TimeI.makeXMLQuantity(d, unit);
  }

  public static Time makeTime(
      double d, Unit<ome.units.quantity.Time> unit) {
    return new TimeI(d, unit);
  }

  public static Time makeTime(double d, UnitsTime unit) {
    return new TimeI(d, unit);
  }

  /**
   * Convert a Bio-Formats {@link Time} to an OMERO Time. A null will be
   * returned if the input is null.
   */
  public static Time convertTime(ome.units.quantity.Time value) {
    if (value == null)
      return null;
    String internal = xmlTimeEnumToOMERO(value.unit().getSymbol());
    UnitsTime ul = UnitsTime.valueOf(internal);
    return new omero.model.TimeI(value.value().doubleValue(), ul);
  }

  public static ome.units.quantity.Time convertTime(Time t) {
    return TimeI.convert(t);
  }

  public static Time convertTime(Time value, Unit<ome.units.quantity.Time> ul)
      throws BigResult {
    return convertTimeXML(value, ul.getSymbol());
  }

  public static Time convertTimeXML(Time value, String xml) throws BigResult {
    String omero = xmlTimeEnumToOMERO(xml);
    return new TimeI(value, omero);
  }

  public static String xmlTimeEnumToOMERO(Unit<ome.units.quantity.Time> xml) {
    return ome.model.enums.UnitsTime.bySymbol(xml.getSymbol()).toString();
  }

  public static String xmlTimeEnumToOMERO(String xml) {
    return ome.model.enums.UnitsTime.bySymbol(xml).toString();
  }

  public static UnitsLength Plane_PositionX = UnitsLength.valueOf(
      xmlLengthEnumToOMERO(ome.xml.model.Plane.getPositionXUnitXsdDefault()));
  public static UnitsLength Plane_PositionZ = UnitsLength.valueOf(
      xmlLengthEnumToOMERO(ome.xml.model.Plane.getPositionZUnitXsdDefault()));
  public static UnitsLength Plane_PositionY = UnitsLength.valueOf(
      xmlLengthEnumToOMERO(ome.xml.model.Plane.getPositionYUnitXsdDefault()));
  public static UnitsTime Plane_DeltaT = UnitsTime.valueOf(
      xmlTimeEnumToOMERO(ome.xml.model.Plane.getDeltaTUnitXsdDefault()));
  public static UnitsTime Plane_ExposureTime = UnitsTime.valueOf(
      xmlTimeEnumToOMERO(ome.xml.model.Plane.getExposureTimeUnitXsdDefault()));
  public static UnitsLength Shape_StrokeWidth = UnitsLength.valueOf(
      xmlLengthEnumToOMERO(ome.xml.model.Shape.getStrokeWidthUnitXsdDefault()));
  public static UnitsLength Shape_FontSize = UnitsLength.valueOf(
      xmlLengthEnumToOMERO(ome.xml.model.Shape.getFontSizeUnitXsdDefault()));
  public static UnitsElectricPotential DetectorSettings_Voltage =
      UnitsElectricPotential.valueOf(
          xmlElectricPotentialEnumToOMERO(
              ome.xml.model.DetectorSettings.getVoltageUnitXsdDefault()));
  public static UnitsFrequency DetectorSettings_ReadOutRate =
      UnitsFrequency.valueOf(
          xmlFrequencyEnumToOMERO(
              ome.xml.model.DetectorSettings.getReadOutRateUnitXsdDefault()));
  public static UnitsTemperature ImagingEnvironment_Temperature =
      UnitsTemperature.valueOf(
          xmlTemperatureEnumToOMERO(
              ome.xml.model.ImagingEnvironment.getTemperatureUnitXsdDefault()));
  public static UnitsPressure ImagingEnvironment_AirPressure =
      UnitsPressure.valueOf(
          xmlPressureEnumToOMERO(
              ome.xml.model.ImagingEnvironment.getAirPressureUnitXsdDefault()));
  public static UnitsLength LightSourceSettings_Wavelength =
      UnitsLength.valueOf(
          xmlLengthEnumToOMERO(
              ome.xml.model.LightSourceSettings.getWavelengthUnitXsdDefault()));
  public static UnitsLength Plate_WellOriginX = UnitsLength.valueOf(
      xmlLengthEnumToOMERO(
          ome.xml.model.Plate.getWellOriginXUnitXsdDefault()));
  public static UnitsLength Plate_WellOriginY =
      UnitsLength.valueOf(
          xmlLengthEnumToOMERO(
              ome.xml.model.Plate.getWellOriginYUnitXsdDefault()));
  public static UnitsLength Objective_WorkingDistance =
      UnitsLength.valueOf(
          xmlLengthEnumToOMERO(
              ome.xml.model.Objective.getWorkingDistanceUnitXsdDefault()));
  public static UnitsLength Pixels_PhysicalSizeX = UnitsLength.valueOf(
      xmlLengthEnumToOMERO(
          ome.xml.model.Pixels.getPhysicalSizeXUnitXsdDefault()));
  public static UnitsLength Pixels_PhysicalSizeZ = UnitsLength.valueOf(
      xmlLengthEnumToOMERO(
          ome.xml.model.Pixels.getPhysicalSizeZUnitXsdDefault()));
  public static UnitsLength Pixels_PhysicalSizeY = UnitsLength.valueOf(
      xmlLengthEnumToOMERO(
          ome.xml.model.Pixels.getPhysicalSizeYUnitXsdDefault()));
  public static UnitsTime Pixels_TimeIncrement = UnitsTime.valueOf(
      xmlTimeEnumToOMERO(
          ome.xml.model.Pixels.getTimeIncrementUnitXsdDefault()));
  public static UnitsLength StageLabel_Z = UnitsLength.valueOf(
      xmlLengthEnumToOMERO(
          ome.xml.model.StageLabel.getZUnitXsdDefault()));
  public static UnitsLength StageLabel_Y = UnitsLength.valueOf(
      xmlLengthEnumToOMERO(ome.xml.model.StageLabel.getYUnitXsdDefault()));
  public static UnitsLength StageLabel_X = UnitsLength.valueOf(
      xmlLengthEnumToOMERO(ome.xml.model.StageLabel.getXUnitXsdDefault()));
  public static UnitsPower LightSource_Power = UnitsPower.valueOf(
      xmlPowerEnumToOMERO(ome.xml.model.LightSource.getPowerUnitXsdDefault()));
  public static UnitsElectricPotential Detector_Voltage =
      UnitsElectricPotential.valueOf(
          xmlElectricPotentialEnumToOMERO(
              ome.xml.model.Detector.getVoltageUnitXsdDefault()));
  public static UnitsLength WellSample_PositionX = UnitsLength.valueOf(
      xmlLengthEnumToOMERO(
          ome.xml.model.WellSample.getPositionXUnitXsdDefault()));
  public static UnitsLength WellSample_PositionY = UnitsLength.valueOf(
      xmlLengthEnumToOMERO(
          ome.xml.model.WellSample.getPositionYUnitXsdDefault()));
  public static UnitsLength Channel_EmissionWavelength = UnitsLength.valueOf(
      xmlLengthEnumToOMERO(
          ome.xml.model.Channel.getEmissionWavelengthUnitXsdDefault()));
  public static UnitsLength Channel_PinholeSize = UnitsLength.valueOf(
      xmlLengthEnumToOMERO(
          ome.xml.model.Channel.getPinholeSizeUnitXsdDefault()));
  public static UnitsLength Channel_ExcitationWavelength = UnitsLength.valueOf(
      xmlLengthEnumToOMERO(
          ome.xml.model.Channel.getExcitationWavelengthUnitXsdDefault()));
  public static UnitsLength TransmittanceRange_CutOutTolerance =
      UnitsLength.valueOf(
          xmlLengthEnumToOMERO(
              ome.xml.model.TransmittanceRange.
                  getCutOutToleranceUnitXsdDefault()));
  public static UnitsLength TransmittanceRange_CutInTolerance =
      UnitsLength.valueOf(
          xmlLengthEnumToOMERO(
              ome.xml.model.TransmittanceRange.
                  getCutInToleranceUnitXsdDefault()));
  public static UnitsLength TransmittanceRange_CutOut = UnitsLength.valueOf(
      xmlLengthEnumToOMERO(
          ome.xml.model.TransmittanceRange.getCutOutUnitXsdDefault()));
  public static UnitsLength TransmittanceRange_CutIn = UnitsLength.valueOf(
      xmlLengthEnumToOMERO(
          ome.xml.model.TransmittanceRange.getCutInUnitXsdDefault()));
  public static UnitsFrequency Laser_RepetitionRate = UnitsFrequency.valueOf(
      xmlFrequencyEnumToOMERO(
          ome.xml.model.Laser.getRepetitionRateUnitXsdDefault()));
  public static UnitsLength Laser_Wavelength = UnitsLength.valueOf(
      xmlLengthEnumToOMERO(ome.xml.model.Laser.getWavelengthUnitXsdDefault()));

}