[libcamera-devel] [PATCH 1/2] libcamera: geometry: Add Size members to grown or shrink by a margin

[Kieran Bingham]

Quoting Laurent Pinchart (2021-10-13 02:26:29)
> Add four new member functions to the Size class (two in-place and two
> const) to grow and shrink a Size by given margins.
> 

Interesting helpers.
I like the use of language for grow/grown shrink/shrunk to differentiate
the actions.

Reviewed-by: Kieran Bingham <kieran.bingham at ideasonboard.com>

> Signed-off-by: Laurent Pinchart <laurent.pinchart at ideasonboard.com>
> ---
>  include/libcamera/geometry.h | 30 ++++++++++++++++++++++
>  src/libcamera/geometry.cpp   | 42 +++++++++++++++++++++++++++++++
>  test/geometry.cpp            | 48 ++++++++++++++++++++++++++++++++----
>  3 files changed, 115 insertions(+), 5 deletions(-)
> 
> diff --git a/include/libcamera/geometry.h b/include/libcamera/geometry.h
> index fdd1b4678074..fa7ae7bce8db 100644
> --- a/include/libcamera/geometry.h
> +++ b/include/libcamera/geometry.h
> @@ -94,6 +94,20 @@ public:
>                 return *this;
>         }
>  
> +       Size &growBy(const Size &margins)
> +       {
> +               width += margins.width;
> +               height += margins.height;
> +               return *this;
> +       }
> +
> +       Size &shrinkBy(const Size &margins)
> +       {
> +               width = width > margins.width ? width - margins.width : 0;
> +               height = height > margins.height ? height - margins.height : 0;
> +               return *this;
> +       }
> +
>         __nodiscard constexpr Size alignedDownTo(unsigned int hAlignment,
>                                                  unsigned int vAlignment) const
>         {
> @@ -128,6 +142,22 @@ public:
>                 };
>         }
>  
> +       __nodiscard constexpr Size grownBy(const Size &margins) const
> +       {
> +               return {
> +                       width + margins.width,
> +                       height + margins.height
> +               };
> +       }
> +
> +       __nodiscard constexpr Size shrunkBy(const Size &margins) const
> +       {
> +               return {
> +                       width > margins.width ? width - margins.width : 0,
> +                       height > margins.height ? height - margins.height : 0
> +               };
> +       }
> +
>         __nodiscard Size boundedToAspectRatio(const Size &ratio) const;
>         __nodiscard Size expandedToAspectRatio(const Size &ratio) const;
>  
> diff --git a/src/libcamera/geometry.cpp b/src/libcamera/geometry.cpp
> index b014180e9ba5..cb3c2de18d5e 100644
> --- a/src/libcamera/geometry.cpp
> +++ b/src/libcamera/geometry.cpp
> @@ -173,6 +173,28 @@ const std::string Size::toString() const
>   * \return A reference to this object
>   */
>  
> +/**
> + * \fn Size::growBy(const Size &margins)
> + * \brief Grow the size by \a margins in place
> + * \param[in] margins The margins to add to the size
> + *
> + * This function adds the width and height of the \a margin size to this size.
> + *
> + * \return A reference to this object
> + */
> +
> +/**
> + * \fn Size::shrinkBy(const Size &margins)
> + * \brief Shrink the size by \a margins in place
> + * \param[in] margins The margins to subtract to the size
> + *
> + * This function subtracts the width and height of the \a margin size from this
> + * size. If the width or height of the size are smaller than those of \a
> + * margins, the result is clamped to 0.
> + *
> + * \return A reference to this object
> + */
> +
>  /**
>   * \fn Size::alignedDownTo(unsigned int hAlignment, unsigned int vAlignment)
>   * \brief Align the size down horizontally and vertically
> @@ -209,6 +231,26 @@ const std::string Size::toString() const
>   * height of this size and the \a expand size
>   */
>  
> +/**
> + * \fn Size::grownBy(const Size &margins)
> + * \brief Grow the size by \a margins
> + * \param[in] margins The margins to add to the size
> + * \return A Size whose width and height are the sum of the width and height of
> + * this size and the \a margins size
> + */
> +
> +/**
> + * \fn Size::shrunkBy(const Size &margins)
> + * \brief Shrink the size by \a margins
> + * \param[in] margins The margins to subtract to the size
> + *
> + * If the width or height of the size are smaller than those of \a margins, the
> + * resulting size has its width or height clamped to 0.
> + *
> + * \return A Size whose width and height are the difference of the width and
> + * height of this size and the \a margins size, clamped to 0
> + */
> +
>  /**
>   * \brief Bound the size down to match the aspect ratio given by \a ratio
>   * \param[in] ratio The size whose aspect ratio must be matched
> diff --git a/test/geometry.cpp b/test/geometry.cpp
> index d13c88bf2e40..5125692496b3 100644
> --- a/test/geometry.cpp
> +++ b/test/geometry.cpp
> @@ -104,7 +104,10 @@ protected:
>                         return TestFail;
>                 }
>  
> -               /* Test alignDownTo(), alignUpTo(), boundTo() and expandTo() */
> +               /*
> +                * Test alignDownTo(), alignUpTo(), boundTo(), expandTo(),
> +                * growBy() and shrinkBy()
> +                */
>                 Size s(50, 50);
>  
>                 s.alignDownTo(16, 16);
> @@ -131,14 +134,36 @@ protected:
>                         return TestFail;
>                 }
>  
> -               s.alignDownTo(16, 16).alignUpTo(32, 32)
> -                .boundTo({ 40, 80 }).expandTo({ 16, 80 });
> -               if (s != Size(40, 80)) {
> +               s.growBy({ 10, 20 });
> +               if (s != Size(60, 70)) {
> +                       cout << "Size::growBy() test failed" << endl;
> +                       return TestFail;
> +               }
> +
> +               s.shrinkBy({ 20, 10 });
> +               if (s != Size(40, 60)) {
> +                       cout << "Size::shrinkBy() test failed" << endl;
> +                       return TestFail;
> +               }
> +
> +               s.shrinkBy({ 100, 100 });
> +               if (s != Size(0, 0)) {
> +                       cout << "Size::shrinkBy() clamp test failed" << endl;
> +                       return TestFail;
> +               }
> +
> +               s = Size(50,50).alignDownTo(16, 16).alignUpTo(32, 32)
> +                 .boundTo({ 40, 80 }).expandTo({ 16, 80 })
> +                 .growBy({ 4, 4 }).shrinkBy({ 10, 20 });
> +               if (s != Size(34, 64)) {
>                         cout << "Size chained in-place modifiers test failed" << endl;
>                         return TestFail;
>                 }
>  
> -               /* Test alignedDownTo(), alignedUpTo(), boundedTo() and expandedTo() */
> +               /*
> +                * Test alignedDownTo(), alignedUpTo(), boundedTo(),
> +                * expandedTo(), grownBy() and shrunkBy()
> +                */
>                 if (Size(0, 0).alignedDownTo(16, 8) != Size(0, 0) ||
>                     Size(1, 1).alignedDownTo(16, 8) != Size(0, 0) ||
>                     Size(16, 8).alignedDownTo(16, 8) != Size(16, 8)) {
> @@ -167,6 +192,19 @@ protected:
>                         return TestFail;
>                 }
>  
> +               if (Size(0, 0).grownBy({ 10, 20 }) != Size(10, 20) ||
> +                   Size(200, 50).grownBy({ 10, 20 }) != Size(210, 70)) {
> +                       cout << "Size::grownBy() test failed" << endl;
> +                       return TestFail;
> +               }
> +
> +               if (Size(200, 50).shrunkBy({ 10, 20 }) != Size(190, 30) ||
> +                   Size(200, 50).shrunkBy({ 10, 100 }) != Size(190, 0) ||
> +                   Size(200, 50).shrunkBy({ 300, 20 }) != Size(0, 30)) {
> +                       cout << "Size::shrunkBy() test failed" << endl;
> +                       return TestFail;
> +               }
> +
>                 /* Aspect ratio tests */
>                 if (Size(0, 0).boundedToAspectRatio(Size(4, 3)) != Size(0, 0) ||
>                     Size(1920, 1440).boundedToAspectRatio(Size(16, 9)) != Size(1920, 1080) ||
> -- 
> Regards,
> 
> Laurent Pinchart
>