| /*****************************************************************************/ |
| // Copyright 2006-2007 Adobe Systems Incorporated |
| // All Rights Reserved. |
| // |
| // NOTICE: Adobe permits you to use, modify, and distribute this file in |
| // accordance with the terms of the Adobe license agreement accompanying it. |
| /*****************************************************************************/ |
| |
| /* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_rect.h#2 $ */ |
| /* $DateTime: 2012/06/01 07:28:57 $ */ |
| /* $Change: 832715 $ */ |
| /* $Author: tknoll $ */ |
| |
| /*****************************************************************************/ |
| |
| #ifndef __dng_rect__ |
| #define __dng_rect__ |
| |
| /*****************************************************************************/ |
| |
| #include "dng_exceptions.h" |
| #include "dng_point.h" |
| #include "dng_safe_arithmetic.h" |
| #include "dng_types.h" |
| #include "dng_utils.h" |
| |
| /*****************************************************************************/ |
| |
| class dng_rect |
| { |
| |
| public: |
| |
| int32 t; |
| int32 l; |
| int32 b; |
| int32 r; |
| |
| public: |
| |
| dng_rect () |
| : t (0) |
| , l (0) |
| , b (0) |
| , r (0) |
| { |
| } |
| |
| // Constructs a dng_rect from the top-left and bottom-right corner. |
| // Throws an exception if the resulting height or width are too large to |
| // be represented as an int32. The intent of this is to protect code |
| // that may be computing the height or width directly from the member |
| // variables (instead of going through H() or W()). |
| dng_rect (int32 tt, int32 ll, int32 bb, int32 rr) |
| : t (tt) |
| , l (ll) |
| , b (bb) |
| , r (rr) |
| { |
| int32 dummy; |
| if (!SafeInt32Sub(r, l, &dummy) || |
| !SafeInt32Sub(b, t, &dummy)) |
| { |
| ThrowProgramError ("Overflow in dng_rect constructor"); |
| } |
| } |
| |
| dng_rect (uint32 h, uint32 w) |
| : t (0) |
| , l (0) |
| { |
| if (!ConvertUint32ToInt32(h, &b) || |
| !ConvertUint32ToInt32(w, &r)) |
| { |
| ThrowProgramError ("Overflow in dng_rect constructor"); |
| } |
| } |
| |
| dng_rect (const dng_point &size) |
| : t (0) |
| , l (0) |
| , b (size.v) |
| , r (size.h) |
| { |
| } |
| |
| void Clear () |
| { |
| *this = dng_rect (); |
| } |
| |
| bool operator== (const dng_rect &rect) const; |
| |
| bool operator!= (const dng_rect &rect) const |
| { |
| return !(*this == rect); |
| } |
| |
| bool IsZero () const; |
| |
| bool NotZero () const |
| { |
| return !IsZero (); |
| } |
| |
| bool IsEmpty () const |
| { |
| return (t >= b) || (l >= r); |
| } |
| |
| bool NotEmpty () const |
| { |
| return !IsEmpty (); |
| } |
| |
| // Returns the width of the rectangle, or 0 if r is smaller than l. |
| // Throws an exception if the width is too large to be represented as |
| // a _signed_ int32 (even if it would fit in a uint32). This is |
| // consciously conservative -- there are existing uses of W() where |
| // the result is converted to an int32 without an overflow check, and |
| // we want to make sure no overflow can occur in such cases. We provide |
| // this check in addition to the check performed in the "two-corners" |
| // constructor to protect client code that produes a dng_rect with |
| // excessive size by initializing or modifying the member variables |
| // directly. |
| uint32 W () const |
| { |
| if (r >= l) |
| { |
| int32 width; |
| if (!SafeInt32Sub(r, l, &width)) |
| { |
| ThrowProgramError ("Overflow computing rectangle width"); |
| } |
| return static_cast<uint32>(width); |
| } |
| else |
| { |
| return 0; |
| } |
| } |
| |
| // Returns the height of the rectangle, or 0 if b is smaller than t. |
| // Throws an exception if the height is too large to be represented as |
| // a _signed_ int32 (see W() for rationale). |
| uint32 H () const |
| { |
| if (b >= t) |
| { |
| int32 height; |
| if (!SafeInt32Sub(b, t, &height)) |
| { |
| ThrowProgramError ("Overflow computing rectangle height"); |
| } |
| return static_cast<uint32>(height); |
| } |
| else |
| { |
| return 0; |
| } |
| } |
| |
| dng_point TL () const |
| { |
| return dng_point (t, l); |
| } |
| |
| dng_point TR () const |
| { |
| return dng_point (t, r); |
| } |
| |
| dng_point BL () const |
| { |
| return dng_point (b, l); |
| } |
| |
| dng_point BR () const |
| { |
| return dng_point (b, r); |
| } |
| |
| dng_point Size () const |
| { |
| return dng_point ((int32) H (), (int32) W ()); |
| } |
| |
| real64 Diagonal () const |
| { |
| return hypot ((real64) W (), |
| (real64) H ()); |
| } |
| |
| }; |
| |
| /*****************************************************************************/ |
| |
| class dng_rect_real64 |
| { |
| |
| public: |
| |
| real64 t; |
| real64 l; |
| real64 b; |
| real64 r; |
| |
| public: |
| |
| dng_rect_real64 () |
| : t (0.0) |
| , l (0.0) |
| , b (0.0) |
| , r (0.0) |
| { |
| } |
| |
| dng_rect_real64 (real64 tt, real64 ll, real64 bb, real64 rr) |
| : t (tt) |
| , l (ll) |
| , b (bb) |
| , r (rr) |
| { |
| } |
| |
| dng_rect_real64 (real64 h, real64 w) |
| : t (0) |
| , l (0) |
| , b (h) |
| , r (w) |
| { |
| } |
| |
| dng_rect_real64 (const dng_point_real64 &size) |
| : t (0) |
| , l (0) |
| , b (size.v) |
| , r (size.h) |
| { |
| } |
| |
| dng_rect_real64 (const dng_point_real64 &pt1, |
| const dng_point_real64 &pt2) |
| : t (Min_real64 (pt1.v, pt2.v)) |
| , l (Min_real64 (pt1.h, pt2.h)) |
| , b (Max_real64 (pt1.v, pt2.v)) |
| , r (Max_real64 (pt1.h, pt2.h)) |
| { |
| } |
| |
| dng_rect_real64 (const dng_rect &rect) |
| : t ((real64) rect.t) |
| , l ((real64) rect.l) |
| , b ((real64) rect.b) |
| , r ((real64) rect.r) |
| { |
| } |
| |
| void Clear () |
| { |
| *this = dng_point_real64 (); |
| } |
| |
| bool operator== (const dng_rect_real64 &rect) const; |
| |
| bool operator!= (const dng_rect_real64 &rect) const |
| { |
| return !(*this == rect); |
| } |
| |
| bool IsZero () const; |
| |
| bool NotZero () const |
| { |
| return !IsZero (); |
| } |
| |
| bool IsEmpty () const |
| { |
| return (t >= b) || (l >= r); |
| } |
| |
| bool NotEmpty () const |
| { |
| return !IsEmpty (); |
| } |
| |
| real64 W () const |
| { |
| return Max_real64 (r - l, 0.0); |
| } |
| |
| real64 H () const |
| { |
| return Max_real64 (b - t, 0.0); |
| } |
| |
| dng_point_real64 TL () const |
| { |
| return dng_point_real64 (t, l); |
| } |
| |
| dng_point_real64 TR () const |
| { |
| return dng_point_real64 (t, r); |
| } |
| |
| dng_point_real64 BL () const |
| { |
| return dng_point_real64 (b, l); |
| } |
| |
| dng_point_real64 BR () const |
| { |
| return dng_point_real64 (b, r); |
| } |
| |
| dng_point_real64 Size () const |
| { |
| return dng_point_real64 (H (), W ()); |
| } |
| |
| dng_rect Round () const |
| { |
| return dng_rect (Round_int32 (t), |
| Round_int32 (l), |
| Round_int32 (b), |
| Round_int32 (r)); |
| } |
| |
| real64 Diagonal () const |
| { |
| return hypot (W (), H ()); |
| } |
| |
| }; |
| |
| /*****************************************************************************/ |
| |
| dng_rect operator& (const dng_rect &a, |
| const dng_rect &b); |
| |
| dng_rect operator| (const dng_rect &a, |
| const dng_rect &b); |
| |
| /*****************************************************************************/ |
| |
| dng_rect_real64 operator& (const dng_rect_real64 &a, |
| const dng_rect_real64 &b); |
| |
| dng_rect_real64 operator| (const dng_rect_real64 &a, |
| const dng_rect_real64 &b); |
| |
| /*****************************************************************************/ |
| |
| inline dng_rect operator+ (const dng_rect &a, |
| const dng_point &b) |
| { |
| |
| return dng_rect (a.t + b.v, |
| a.l + b.h, |
| a.b + b.v, |
| a.r + b.h); |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| inline dng_rect_real64 operator+ (const dng_rect_real64 &a, |
| const dng_point_real64 &b) |
| { |
| |
| return dng_rect_real64 (a.t + b.v, |
| a.l + b.h, |
| a.b + b.v, |
| a.r + b.h); |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| inline dng_rect operator- (const dng_rect &a, |
| const dng_point &b) |
| { |
| |
| return dng_rect (a.t - b.v, |
| a.l - b.h, |
| a.b - b.v, |
| a.r - b.h); |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| inline dng_rect_real64 operator- (const dng_rect_real64 &a, |
| const dng_point_real64 &b) |
| { |
| |
| return dng_rect_real64 (a.t - b.v, |
| a.l - b.h, |
| a.b - b.v, |
| a.r - b.h); |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| inline dng_rect Transpose (const dng_rect &a) |
| { |
| |
| return dng_rect (a.l, a.t, a.r, a.b); |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| inline dng_rect_real64 Transpose (const dng_rect_real64 &a) |
| { |
| |
| return dng_rect_real64 (a.l, a.t, a.r, a.b); |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| inline void HalfRect (dng_rect &rect) |
| { |
| |
| rect.r = rect.l + (int32) (rect.W () >> 1); |
| rect.b = rect.t + (int32) (rect.H () >> 1); |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| inline void DoubleRect (dng_rect &rect) |
| { |
| |
| rect.r = rect.l + (int32) (rect.W () << 1); |
| rect.b = rect.t + (int32) (rect.H () << 1); |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| inline void InnerPadRect (dng_rect &rect, |
| int32 pad) |
| { |
| |
| rect.l += pad; |
| rect.r -= pad; |
| rect.t += pad; |
| rect.b -= pad; |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| inline void OuterPadRect (dng_rect &rect, |
| int32 pad) |
| { |
| |
| InnerPadRect (rect, -pad); |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| inline void InnerPadRectH (dng_rect &rect, |
| int32 pad) |
| { |
| |
| rect.l += pad; |
| rect.r -= pad; |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| inline void InnerPadRectV (dng_rect &rect, |
| int32 pad) |
| { |
| |
| rect.t += pad; |
| rect.b -= pad; |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| inline dng_rect MakeHalfRect (const dng_rect &rect) |
| { |
| |
| dng_rect out = rect; |
| |
| HalfRect (out); |
| |
| return out; |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| inline dng_rect MakeDoubleRect (const dng_rect &rect) |
| { |
| |
| dng_rect out = rect; |
| |
| DoubleRect (out); |
| |
| return out; |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| inline dng_rect MakeInnerPadRect (const dng_rect &rect, |
| int32 pad) |
| { |
| |
| dng_rect out = rect; |
| |
| InnerPadRect (out, pad); |
| |
| return out; |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| inline dng_rect MakeOuterPadRect (const dng_rect &rect, |
| int32 pad) |
| { |
| |
| dng_rect out = rect; |
| |
| OuterPadRect (out, pad); |
| |
| return out; |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| #endif |
| |
| /*****************************************************************************/ |
