image/Orientation.h

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #ifndef mozilla_image_Orientation_h
   7 #define mozilla_image_Orientation_h
   8
   9 #include <stdint.h>
  10 #include "mozilla/gfx/Rect.h"
  11
  12 namespace mozilla {
  13
  14 // Pixel values in an image considering orientation metadata, such as the size
  15 // of an image as seen by consumers of the image.
  16 //
  17 // Any public methods on RasterImage that use untyped units are interpreted as
  18 // oriented pixels.
  19 struct OrientedPixel {};
  20 template <>
  21 struct IsPixel<OrientedPixel> : std::true_type {};
  22 typedef gfx::IntPointTyped<OrientedPixel> OrientedIntPoint;
  23 typedef gfx::IntSizeTyped<OrientedPixel> OrientedIntSize;
  24 typedef gfx::IntRectTyped<OrientedPixel> OrientedIntRect;
  25
  26 // Pixel values in an image ignoring orientation metadata, such as are stored
  27 // in surfaces and the raw pixel data in the image.
  28 struct UnorientedPixel {};
  29 template <>
  30 struct IsPixel<UnorientedPixel> : std::true_type {};
  31 typedef gfx::IntPointTyped<UnorientedPixel> UnorientedIntPoint;
  32 typedef gfx::IntSizeTyped<UnorientedPixel> UnorientedIntSize;
  33 typedef gfx::IntRectTyped<UnorientedPixel> UnorientedIntRect;
  34
  35 namespace image {
  36
  37 enum class Angle : uint8_t { D0, D90, D180, D270 };
  38
  39 enum class Flip : uint8_t { Unflipped, Horizontal };
  40
  41 /**
  42  * A struct that describes an image's orientation as a rotation optionally
  43  * followed by a reflection. This may be used to be indicate an image's inherent
  44  * orientation or a desired orientation for the image.
  45  *
  46  * When flipFirst = true, this indicates that the reflection is applied before
  47  * the rotation. (This is used by OrientedImage to represent the inverse of an
  48  * underlying image's Orientation.)
  49  */
  50 struct Orientation {
  51   explicit Orientation(Angle aRotation = Angle::D0,
  52                        Flip aFlip = Flip::Unflipped, bool aFlipFirst = false)
  53       : rotation(aRotation), flip(aFlip), flipFirst(aFlipFirst) {}
  54
  55   Orientation Reversed() const {
  56     return Orientation(InvertAngle(rotation), flip, !flipFirst);
  57   }
  58
  59   bool IsIdentity() const {
  60     return (rotation == Angle::D0) && (flip == Flip::Unflipped);
  61   }
  62
  63   bool SwapsWidthAndHeight() const {
  64     return (rotation == Angle::D90) || (rotation == Angle::D270);
  65   }
  66
  67   bool operator==(const Orientation& aOther) const {
  68     return rotation == aOther.rotation && flip == aOther.flip &&
  69            flipFirst == aOther.flipFirst;
  70   }
  71
  72   bool operator!=(const Orientation& aOther) const {
  73     return !(*this == aOther);
  74   }
  75
  76   OrientedIntSize ToOriented(const UnorientedIntSize& aSize) const {
  77     if (SwapsWidthAndHeight()) {
  78       return OrientedIntSize(aSize.height, aSize.width);
  79     } else {
  80       return OrientedIntSize(aSize.width, aSize.height);
  81     }
  82   }
  83
  84   UnorientedIntSize ToUnoriented(const OrientedIntSize& aSize) const {
  85     if (SwapsWidthAndHeight()) {
  86       return UnorientedIntSize(aSize.height, aSize.width);
  87     } else {
  88       return UnorientedIntSize(aSize.width, aSize.height);
  89     }
  90   }
  91
  92   static Angle InvertAngle(Angle aAngle) {
  93     switch (aAngle) {
  94       case Angle::D90:
  95         return Angle::D270;
  96       case Angle::D270:
  97         return Angle::D90;
  98       default:
  99         return aAngle;
 100     }
 101   }
 102
 103   Angle rotation;
 104   Flip flip;
 105   bool flipFirst;
 106 };
 107
 108 }  // namespace image
 109 }  // namespace mozilla
 110
 111 #endif  // mozilla_image_Orientation_h