length.h

Go to the documentation of this file.

/*
 * #%L
 * OME-COMMON C++ library for C++ compatibility/portability
 * %%
 * Copyright © 2015 Open Microscopy Environment:
 *   - Massachusetts Institute of Technology
 *   - National Institutes of Health
 *   - University of Dundee
 *   - Board of Regents of the University of Wisconsin-Madison
 *   - Glencoe Software, Inc.
 * %%
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *
 * The views and conclusions contained in the software and documentation are
 * those of the authors and should not be interpreted as representing official
 * policies, either expressed or implied, of any organization.
 * #L%
 */

#ifndef OME_COMMON_UNITS_LENGTH_H
#define OME_COMMON_UNITS_LENGTH_H

#include <ome/common/config.h>
#include <ome/common/units/types.h>

#include <boost/units/base_units/astronomical/astronomical_unit.hpp>
#include <boost/units/base_units/astronomical/light_year.hpp>
#include <boost/units/base_units/astronomical/parsec.hpp>
#include <boost/units/base_units/imperial/thou.hpp>
#include <boost/units/base_units/imperial/inch.hpp>
#include <boost/units/base_units/imperial/foot.hpp>
#include <boost/units/base_units/imperial/yard.hpp>
#include <boost/units/base_units/imperial/mile.hpp>
#include <boost/units/base_units/metric/micron.hpp>
#include <boost/units/base_units/metric/angstrom.hpp>
#include <boost/units/unit.hpp>
#include <boost/units/quantity.hpp>
#include <boost/units/systems/si.hpp>

namespace ome
{
  namespace common
  {
    namespace units
    {

      // Length types, constants and quantities.

      typedef si::length length_unit;
      typedef quantity<si::length> length_quantity;

      typedef make_scaled_unit<si::length,scale<10,static_rational<-24>>>::type yoctometre_unit;
      typedef make_scaled_unit<si::length,scale<10,static_rational<-21>>>::type zeptometre_unit;
      typedef make_scaled_unit<si::length,scale<10,static_rational<-18>>>::type attometre_unit;
      typedef make_scaled_unit<si::length,scale<10,static_rational<-15>>>::type femtometre_unit;
      typedef make_scaled_unit<si::length,scale<10,static_rational<-12>>>::type picometre_unit;
      typedef make_scaled_unit<si::length,scale<10,static_rational< -9>>>::type nanometre_unit;
      typedef make_scaled_unit<si::length,scale<10,static_rational< -6>>>::type micrometre_unit;
      typedef make_scaled_unit<si::length,scale<10,static_rational< -3>>>::type millimetre_unit;
      typedef make_scaled_unit<si::length,scale<10,static_rational< -2>>>::type centimetre_unit;
      typedef make_scaled_unit<si::length,scale<10,static_rational< -1>>>::type decimetre_unit;
      typedef make_scaled_unit<si::length,scale<10,static_rational<  0>>>::type metre_unit;
      typedef make_scaled_unit<si::length,scale<10,static_rational<  1>>>::type dekametre_unit;
      typedef make_scaled_unit<si::length,scale<10,static_rational<  1>>>::type decametre_unit;
      typedef make_scaled_unit<si::length,scale<10,static_rational<  2>>>::type hectometre_unit;
      typedef make_scaled_unit<si::length,scale<10,static_rational<  3>>>::type kilometre_unit;
      typedef make_scaled_unit<si::length,scale<10,static_rational<  6>>>::type megametre_unit;
      typedef make_scaled_unit<si::length,scale<10,static_rational<  9>>>::type gigametre_unit;
      typedef make_scaled_unit<si::length,scale<10,static_rational< 12>>>::type terametre_unit;
      typedef make_scaled_unit<si::length,scale<10,static_rational< 15>>>::type petametre_unit;
      typedef make_scaled_unit<si::length,scale<10,static_rational< 18>>>::type exametre_unit;
      typedef make_scaled_unit<si::length,scale<10,static_rational< 21>>>::type zettametre_unit;
      typedef make_scaled_unit<si::length,scale<10,static_rational< 24>>>::type yottametre_unit;

      typedef yoctometre_unit yoctometer_unit;
      typedef zeptometre_unit zeptometer_unit;
      typedef attometre_unit attometer_unit;
      typedef femtometre_unit femtometer_unit;
      typedef picometre_unit picometer_unit;
      typedef nanometre_unit nanometer_unit;
      typedef micrometre_unit micrometer_unit;
      typedef millimetre_unit millimeter_unit;
      typedef centimetre_unit centimeter_unit;
      typedef decimetre_unit decimeter_unit;
      typedef metre_unit meter_unit;
      typedef dekametre_unit dekameter_unit;
      typedef decametre_unit decameter_unit;
      typedef hectometre_unit hectometer_unit;
      typedef kilometre_unit kilometer_unit;
      typedef megametre_unit megameter_unit;
      typedef gigametre_unit gigameter_unit;
      typedef terametre_unit terameter_unit;
      typedef petametre_unit petameter_unit;
      typedef exametre_unit exameter_unit;
      typedef zettametre_unit zettameter_unit;
      typedef yottametre_unit yottameter_unit;

      BOOST_UNITS_STATIC_CONSTANT(yoctometre, yoctometre_unit);
      BOOST_UNITS_STATIC_CONSTANT(zeptometre, zeptometre_unit);
      BOOST_UNITS_STATIC_CONSTANT(attometre, attometre_unit);
      BOOST_UNITS_STATIC_CONSTANT(femtometre, femtometre_unit);
      BOOST_UNITS_STATIC_CONSTANT(picometre, picometre_unit);
      BOOST_UNITS_STATIC_CONSTANT(nanometre, nanometre_unit);
      BOOST_UNITS_STATIC_CONSTANT(micrometre, micrometre_unit);
      BOOST_UNITS_STATIC_CONSTANT(millimetre, millimetre_unit);
      BOOST_UNITS_STATIC_CONSTANT(centimetre, centimetre_unit);
      BOOST_UNITS_STATIC_CONSTANT(decimetre, decimetre_unit);
      BOOST_UNITS_STATIC_CONSTANT(metre, metre_unit);
      BOOST_UNITS_STATIC_CONSTANT(dekametre, dekametre_unit);
      BOOST_UNITS_STATIC_CONSTANT(decametre, decametre_unit);
      BOOST_UNITS_STATIC_CONSTANT(hectometre, hectometre_unit);
      BOOST_UNITS_STATIC_CONSTANT(kilometre, kilometre_unit);
      BOOST_UNITS_STATIC_CONSTANT(megametre, megametre_unit);
      BOOST_UNITS_STATIC_CONSTANT(gigametre, gigametre_unit);
      BOOST_UNITS_STATIC_CONSTANT(terametre, terametre_unit);
      BOOST_UNITS_STATIC_CONSTANT(petametre, petametre_unit);
      BOOST_UNITS_STATIC_CONSTANT(exametre, exametre_unit);
      BOOST_UNITS_STATIC_CONSTANT(zettametre, zettametre_unit);
      BOOST_UNITS_STATIC_CONSTANT(yottametre, yottametre_unit);

      BOOST_UNITS_STATIC_CONSTANT(yoctometres, yoctometre_unit);
      BOOST_UNITS_STATIC_CONSTANT(zeptometres, zeptometre_unit);
      BOOST_UNITS_STATIC_CONSTANT(attometres, attometre_unit);
      BOOST_UNITS_STATIC_CONSTANT(femtometres, femtometre_unit);
      BOOST_UNITS_STATIC_CONSTANT(picometres, picometre_unit);
      BOOST_UNITS_STATIC_CONSTANT(nanometres, nanometre_unit);
      BOOST_UNITS_STATIC_CONSTANT(micrometres, micrometre_unit);
      BOOST_UNITS_STATIC_CONSTANT(millimetres, millimetre_unit);
      BOOST_UNITS_STATIC_CONSTANT(centimetres, centimetre_unit);
      BOOST_UNITS_STATIC_CONSTANT(decimetres, decimetre_unit);
      BOOST_UNITS_STATIC_CONSTANT(metres, metre_unit);
      BOOST_UNITS_STATIC_CONSTANT(dekametres, dekametre_unit);
      BOOST_UNITS_STATIC_CONSTANT(decametres, decametre_unit);
      BOOST_UNITS_STATIC_CONSTANT(hectometres, hectometre_unit);
      BOOST_UNITS_STATIC_CONSTANT(kilometres, kilometre_unit);
      BOOST_UNITS_STATIC_CONSTANT(megametres, megametre_unit);
      BOOST_UNITS_STATIC_CONSTANT(gigametres, gigametre_unit);
      BOOST_UNITS_STATIC_CONSTANT(terametres, terametre_unit);
      BOOST_UNITS_STATIC_CONSTANT(petametres, petametre_unit);
      BOOST_UNITS_STATIC_CONSTANT(exametres, exametre_unit);
      BOOST_UNITS_STATIC_CONSTANT(zettametres, zettametre_unit);
      BOOST_UNITS_STATIC_CONSTANT(yottametres, yottametre_unit);

      BOOST_UNITS_STATIC_CONSTANT(yoctometer, yoctometer_unit);
      BOOST_UNITS_STATIC_CONSTANT(zeptometer, zeptometer_unit);
      BOOST_UNITS_STATIC_CONSTANT(attometer, attometer_unit);
      BOOST_UNITS_STATIC_CONSTANT(femtometer, femtometer_unit);
      BOOST_UNITS_STATIC_CONSTANT(picometer, picometer_unit);
      BOOST_UNITS_STATIC_CONSTANT(nanometer, nanometer_unit);
      BOOST_UNITS_STATIC_CONSTANT(micrometer, micrometer_unit);
      BOOST_UNITS_STATIC_CONSTANT(millimeter, millimeter_unit);
      BOOST_UNITS_STATIC_CONSTANT(centimeter, centimeter_unit);
      BOOST_UNITS_STATIC_CONSTANT(decimeter, decimeter_unit);
      BOOST_UNITS_STATIC_CONSTANT(meter, meter_unit);
      BOOST_UNITS_STATIC_CONSTANT(dekameter, dekameter_unit);
      BOOST_UNITS_STATIC_CONSTANT(decameter, decameter_unit);
      BOOST_UNITS_STATIC_CONSTANT(hectometer, hectometer_unit);
      BOOST_UNITS_STATIC_CONSTANT(kilometer, kilometer_unit);
      BOOST_UNITS_STATIC_CONSTANT(megameter, megameter_unit);
      BOOST_UNITS_STATIC_CONSTANT(gigameter, gigameter_unit);
      BOOST_UNITS_STATIC_CONSTANT(terameter, terameter_unit);
      BOOST_UNITS_STATIC_CONSTANT(petameter, petameter_unit);
      BOOST_UNITS_STATIC_CONSTANT(exameter, exameter_unit);
      BOOST_UNITS_STATIC_CONSTANT(zettameter, zettameter_unit);
      BOOST_UNITS_STATIC_CONSTANT(yottameter, yottameter_unit);

      BOOST_UNITS_STATIC_CONSTANT(yoctometers, yoctometer_unit);
      BOOST_UNITS_STATIC_CONSTANT(zeptometers, zeptometer_unit);
      BOOST_UNITS_STATIC_CONSTANT(attometers, attometer_unit);
      BOOST_UNITS_STATIC_CONSTANT(femtometers, femtometer_unit);
      BOOST_UNITS_STATIC_CONSTANT(picometers, picometer_unit);
      BOOST_UNITS_STATIC_CONSTANT(nanometers, nanometer_unit);
      BOOST_UNITS_STATIC_CONSTANT(micrometers, micrometer_unit);
      BOOST_UNITS_STATIC_CONSTANT(millimeters, millimeter_unit);
      BOOST_UNITS_STATIC_CONSTANT(centimeters, centimeter_unit);
      BOOST_UNITS_STATIC_CONSTANT(decimeters, decimeter_unit);
      BOOST_UNITS_STATIC_CONSTANT(meters, meter_unit);
      BOOST_UNITS_STATIC_CONSTANT(dekameters, dekameter_unit);
      BOOST_UNITS_STATIC_CONSTANT(decameters, decameter_unit);
      BOOST_UNITS_STATIC_CONSTANT(hectometers, hectometer_unit);
      BOOST_UNITS_STATIC_CONSTANT(kilometers, kilometer_unit);
      BOOST_UNITS_STATIC_CONSTANT(megameters, megameter_unit);
      BOOST_UNITS_STATIC_CONSTANT(gigameters, gigameter_unit);
      BOOST_UNITS_STATIC_CONSTANT(terameters, terameter_unit);
      BOOST_UNITS_STATIC_CONSTANT(petameters, petameter_unit);
      BOOST_UNITS_STATIC_CONSTANT(exameters, exameter_unit);
      BOOST_UNITS_STATIC_CONSTANT(zettameters, zettameter_unit);
      BOOST_UNITS_STATIC_CONSTANT(yottameters, yottameter_unit);

      typedef quantity<yoctometre_unit> yoctometre_quantity;
      typedef quantity<zeptometre_unit> zeptometre_quantity;
      typedef quantity<attometre_unit> attometre_quantity;
      typedef quantity<femtometre_unit> femtometre_quantity;
      typedef quantity<picometre_unit> picometre_quantity;
      typedef quantity<nanometre_unit> nanometre_quantity;
      typedef quantity<micrometre_unit> micrometre_quantity;
      typedef quantity<millimetre_unit> millimetre_quantity;
      typedef quantity<centimetre_unit> centimetre_quantity;
      typedef quantity<decimetre_unit> decimetre_quantity;
      typedef quantity<metre_unit> metre_quantity;
      typedef quantity<dekametre_unit> dekametre_quantity;
      typedef quantity<decametre_unit> decametre_quantity;
      typedef quantity<hectometre_unit> hectometre_quantity;
      typedef quantity<kilometre_unit> kilometre_quantity;
      typedef quantity<megametre_unit> megametre_quantity;
      typedef quantity<gigametre_unit> gigametre_quantity;
      typedef quantity<terametre_unit> terametre_quantity;
      typedef quantity<petametre_unit> petametre_quantity;
      typedef quantity<exametre_unit> exametre_quantity;
      typedef quantity<zettametre_unit> zettametre_quantity;
      typedef quantity<yottametre_unit> yottametre_quantity;

      typedef quantity<yoctometer_unit> yoctometer_quantity;
      typedef quantity<zeptometer_unit> zeptometer_quantity;
      typedef quantity<attometer_unit> attometer_quantity;
      typedef quantity<femtometer_unit> femtometer_quantity;
      typedef quantity<picometer_unit> picometer_quantity;
      typedef quantity<nanometer_unit> nanometer_quantity;
      typedef quantity<micrometer_unit> micrometer_quantity;
      typedef quantity<millimeter_unit> millimeter_quantity;
      typedef quantity<centimeter_unit> centimeter_quantity;
      typedef quantity<decimeter_unit> decimeter_quantity;
      typedef quantity<meter_unit> meter_quantity;
      typedef quantity<dekameter_unit> dekameter_quantity;
      typedef quantity<decameter_unit> decameter_quantity;
      typedef quantity<hectometer_unit> hectometer_quantity;
      typedef quantity<kilometer_unit> kilometer_quantity;
      typedef quantity<megameter_unit> megameter_quantity;
      typedef quantity<gigameter_unit> gigameter_quantity;
      typedef quantity<terameter_unit> terameter_quantity;
      typedef quantity<petameter_unit> petameter_quantity;
      typedef quantity<exameter_unit> exameter_quantity;
      typedef quantity<zettameter_unit> zettameter_quantity;
      typedef quantity<yottameter_unit> yottameter_quantity;

      typedef boost::units::metric::angstrom_base_unit::unit_type angstrom_unit;
      BOOST_UNITS_STATIC_CONSTANT(angstrom, angstrom_unit);
      BOOST_UNITS_STATIC_CONSTANT(angstroms, angstrom_unit);
      typedef quantity<angstrom_unit> angstrom_quantity;

      typedef boost::units::imperial::thou_base_unit::unit_type thou_unit;
      BOOST_UNITS_STATIC_CONSTANT(thou, thou_unit);
      BOOST_UNITS_STATIC_CONSTANT(thous, thou_unit);
      typedef quantity<thou_unit> thou_quantity;

      typedef scaled_base_unit<boost::units::imperial::inch_base_unit, scale<12, static_rational<-1>>> line_base_unit;
      typedef line_base_unit::unit_type line_unit;
      BOOST_UNITS_STATIC_CONSTANT(line, line_unit);
      BOOST_UNITS_STATIC_CONSTANT(lines, line_unit);
      typedef quantity<line_unit> line_quantity;

      typedef boost::units::imperial::inch_base_unit::unit_type inch_unit;
      BOOST_UNITS_STATIC_CONSTANT(inch, inch_unit);
      BOOST_UNITS_STATIC_CONSTANT(inches, inch_unit);
      typedef quantity<inch_unit> inch_quantity;

      typedef boost::units::imperial::foot_base_unit::unit_type foot_unit;
      BOOST_UNITS_STATIC_CONSTANT(foot, foot_unit);
      BOOST_UNITS_STATIC_CONSTANT(feet, foot_unit);
      typedef quantity<foot_unit> foot_quantity;

      typedef boost::units::imperial::yard_base_unit::unit_type yard_unit;
      BOOST_UNITS_STATIC_CONSTANT(yard, yard_unit);
      BOOST_UNITS_STATIC_CONSTANT(yards, yard_unit);
      typedef quantity<yard_unit> yard_quantity;

      typedef boost::units::imperial::mile_base_unit::unit_type mile_unit;
      BOOST_UNITS_STATIC_CONSTANT(mile, mile_unit);
      BOOST_UNITS_STATIC_CONSTANT(miles, mile_unit);
      typedef quantity<mile_unit> mile_quantity;

      typedef boost::units::astronomical::astronomical_unit_base_unit::unit_type astronomical_unit_unit;
      BOOST_UNITS_STATIC_CONSTANT(astronomical_unit, astronomical_unit_unit);
      BOOST_UNITS_STATIC_CONSTANT(astronomical_units, astronomical_unit_unit);
      typedef quantity<astronomical_unit_unit> astronomical_unit_quantity;

      typedef boost::units::astronomical::light_year_base_unit::unit_type light_year_unit;
      BOOST_UNITS_STATIC_CONSTANT(light_year, light_year_unit);
      BOOST_UNITS_STATIC_CONSTANT(light_years, light_year_unit);
      typedef quantity<light_year_unit> light_year_quantity;

      typedef boost::units::astronomical::parsec_base_unit::unit_type parsec_unit;
      BOOST_UNITS_STATIC_CONSTANT(parsec, parsec_unit);
      BOOST_UNITS_STATIC_CONSTANT(parsecs, parsec_unit);
      typedef quantity<parsec_unit> parsec_quantity;

      typedef scaled_base_unit<boost::units::imperial::inch_base_unit, scale<72, static_rational<-1>>> point_base_unit;
      typedef point_base_unit::unit_type point_unit;
      BOOST_UNITS_STATIC_CONSTANT(point, point_unit);
      BOOST_UNITS_STATIC_CONSTANT(points, point_unit);
      typedef quantity<point_unit> point_quantity;

      struct pixel_base_unit : boost::units::base_unit<pixel_base_unit,
                                                       boost::units::length_dimension, 1> { };
      typedef boost::units::make_system<
        pixel_base_unit>::type pixel_system;
      typedef boost::units::unit<boost::units::length_dimension, pixel_system> pixel_unit;
      BOOST_UNITS_STATIC_CONSTANT(pixel, pixel_unit);
      BOOST_UNITS_STATIC_CONSTANT(pixels, pixel_unit);
      typedef quantity<pixel_unit> pixel_quantity;

      struct reference_frame_base_unit : boost::units::base_unit<reference_frame_base_unit,
                                                                 boost::units::length_dimension, 2> { };
      typedef boost::units::make_system<
        reference_frame_base_unit>::type reference_frame_system;
      typedef boost::units::unit<boost::units::length_dimension, reference_frame_system> reference_frame_unit;
      BOOST_UNITS_STATIC_CONSTANT(reference_frame, reference_frame_unit);
      typedef quantity<reference_frame_unit> reference_frame_quantity;

    }
  }
}

namespace boost
{
  namespace units
  {

    template<> struct base_unit_info<ome::common::units::line_base_unit>
    {
      static std::string name()   { return "line"; }
      static std::string symbol() { return "li"; }
    };

    template<> struct base_unit_info<ome::common::units::point_base_unit>
    {
      static std::string name()   { return "point"; }
      static std::string symbol() { return "pt"; }
    };

    template<> struct base_unit_info<ome::common::units::pixel_base_unit>
    {
      static std::string name()   { return "pixel"; }
      static std::string symbol() { return "px"; }
    };

    template<> struct base_unit_info<ome::common::units::reference_frame_base_unit>
    {
      static std::string name()   { return "reference frame"; }
      static std::string symbol() { return "r.f."; }
    };

  }
}

#endif // OME_COMMON_UNITS_LENGTH_H

/*
 * Local Variables:
 * mode:C++
 * End:
 */