Skip to content

D
dlib
Commit e0f7b41a authored by Davis King's avatar Davis King
Browse files
Options

Added the drectangle object and switched a few interpolation related APIs over 

to use it.
parent e485838b
Hide whitespace changes
Inline Side-by-side
Showing with 949 additions and 77 deletions
dlib/geometry.h
View file @ e0f7b41a
...@@ -4,6 +4,7 @@ ...@@ -4,6 +4,7 @@
#define DLIB_GEOMETRy_HEADER #define DLIB_GEOMETRy_HEADER
#include "geometry/rectangle.h" #include "geometry/rectangle.h"
#include "geometry/drectangle.h"
#include "geometry/vector.h" #include "geometry/vector.h"
#include "geometry/border_enumerator.h" #include "geometry/border_enumerator.h"
#include "geometry/point_transforms.h" #include "geometry/point_transforms.h"
......
dlib/geometry/drectangle.h 0 → 100644
View file @ e0f7b41a
// Copyright (C) 2015 Davis E. King (davis@dlib.net)
// License: Boost Software License See LICENSE.txt for the full license.
#ifndef DLIB_DRECTANGLe_
#define DLIB_DRECTANGLe_
#include "drectangle_abstract.h"
#include "rectangle.h"
namespace dlib
{
class drectangle;
drectangle operator* (
const drectangle& rect,
const double& scale
);
// ----------------------------------------------------------------------------------------
class drectangle
{
public:
drectangle (
) : l(0), t(0), r(-1), b(-1) {}
drectangle (
double l_,
double t_,
double r_,
double b_
) :
l(l_),
t(t_),
r(r_),
b(b_)
{}
drectangle (
const dlib::vector<double,2>& p
) :
l(p.x()),
t(p.y()),
r(p.x()),
b(p.y())
{
}
template <typename T, typename U>
drectangle (
const vector<T,2>& p1,
const vector<U,2>& p2
)
{
*this = drectangle(p1) + drectangle(p2);
}
drectangle (
const rectangle& rect
) : l(rect.left()),
t(rect.top()),
r(rect.right()),
b(rect.bottom()) {}
operator rectangle (
) const
{
return rectangle((long)std::floor(l+0.5),
(long)std::floor(t+0.5),
(long)std::floor(r+0.5),
(long)std::floor(b+0.5));
}
double left() const { return l; }
double top() const { return t; }
double right() const { return r; }
double bottom() const { return b; }
double& left() { return l; }
double& top() { return t; }
double& right() { return r; }
double& bottom() { return b; }
const dlib::vector<double,2> tl_corner (
) const { return dlib::vector<double,2>(left(), top()); }
const dlib::vector<double,2> bl_corner (
) const { return dlib::vector<double,2>(left(), bottom()); }
const dlib::vector<double,2> tr_corner (
) const { return dlib::vector<double,2>(right(), top()); }
const dlib::vector<double,2> br_corner (
) const { return dlib::vector<double,2>(right(), bottom()); }
double width (
) const
{
if (is_empty())
return 0;
else
return r - l;
}
double height (
) const
{
if (is_empty())
return 0;
else
return b - t;
}
double area (
) const
{
return width()*height();
}
bool is_empty (
) const { return (t > b || l > r); }
drectangle operator + (
const drectangle& rhs
) const
{
if (rhs.is_empty())
return *this;
else if (is_empty())
return rhs;
return drectangle (
std::min(l,rhs.l),
std::min(t,rhs.t),
std::max(r,rhs.r),
std::max(b,rhs.b)
);
}
drectangle intersect (
const drectangle& rhs
) const
{
return drectangle (
std::max(l,rhs.l),
std::max(t,rhs.t),
std::min(r,rhs.r),
std::min(b,rhs.b)
);
}
bool contains (
const dlib::vector<double,2>& p
) const
{
if (p.x() < l || p.x() > r || p.y() < t || p.y() > b)
return false;
return true;
}
bool contains (
const drectangle& rect
) const
{
if (rect.is_empty())
return true;
if (l <= rect.left() &&
r >= rect.right() &&
t <= rect.top() &&
b >= rect.bottom())
return true;
return false;
}
drectangle& operator *= (
const double& scale
)
{
*this = *this*scale;
return *this;
}
drectangle& operator /= (
const double& scale
)
{
*this = *this*(1.0/scale);
return *this;
}
private:
double l;
double t;
double r;
double b;
};
// ----------------------------------------------------------------------------------------
inline void serialize (
const drectangle& item,
std::ostream& out
)
{
try
{
serialize(item.left(),out);
serialize(item.top(),out);
serialize(item.right(),out);
serialize(item.bottom(),out);
}
catch (serialization_error& e)
{
throw serialization_error(e.info + "\n while serializing an object of type drectangle");
}
}
inline void deserialize (
drectangle& item,
std::istream& in
)
{
try
{
deserialize(item.left(),in);
deserialize(item.top(),in);
deserialize(item.right(),in);
deserialize(item.bottom(),in);
}
catch (serialization_error& e)
{
throw serialization_error(e.info + "\n while deserializing an object of type drectangle");
}
}
inline std::ostream& operator<< (
std::ostream& out,
const drectangle& item
)
{
out << "[(" << item.left() << ", " << item.top() << ") (" << item.right() << ", " << item.bottom() << ")]";
return out;
}
inline std::istream& operator>>(
std::istream& in,
drectangle& item
)
{
// ignore any whitespace
while (in.peek() == ' ' || in.peek() == '\t' || in.peek() == '\r' || in.peek() == '\n')
in.get();
// now eat the leading '[' character
if (in.get() != '[')
{
in.setstate(in.rdstate() | std::ios::failbit);
return in;
}
dlib::vector<double,2> p1, p2;
in >> p1;
in >> p2;
item = drectangle(p1) + drectangle(p2);
// ignore any whitespace
while (in.peek() == ' ' || in.peek() == '\t' || in.peek() == '\r' || in.peek() == '\n')
in.get();
// now eat the trailing ']' character
if (in.get() != ']')
{
in.setstate(in.rdstate() | std::ios::failbit);
}
return in;
}
// ----------------------------------------------------------------------------------------
inline dlib::vector<double,2> center (
const drectangle& rect
)
{
dlib::vector<double,2> temp(rect.left() + rect.right(),
rect.top() + rect.bottom());
return temp/2.0;
}
inline dlib::vector<double,2> dcenter (
const drectangle& rect
)
{
return center(rect);
}
inline drectangle operator* (
const drectangle& rect,
const double& scale
)
{
const double width = rect.width()*scale;
const double height = rect.height()*scale;
const dlib::vector<double,2> p = center(rect);
return drectangle(p.x()-width/2, p.y()-height/2, p.x()+width/2, p.y()+height/2);
}
inline drectangle operator* (
const double& scale,
const drectangle& rect
)
{
return rect*scale;
}
inline drectangle operator/ (
const drectangle& rect,
const double& scale
)
{
return rect*(1.0/scale);
}
inline drectangle operator+ (
const drectangle& r,
const dlib::vector<double,2>& p
)
{
return r + drectangle(p);
}
inline drectangle operator+ (
const dlib::vector<double,2>& p,
const drectangle& r
)
{
return r + drectangle(p);
}
inline drectangle translate_rect (
const drectangle& rect,
const dlib::vector<double,2>& p
)
{
drectangle result;
result.top () = rect.top() + p.y();
result.bottom () = rect.bottom() + p.y();
result.left () = rect.left() + p.x();
result.right () = rect.right() + p.x();
return result;
}
inline drectangle intersect (
const drectangle& a,
const drectangle& b
) { return a.intersect(b); }
inline double area (
const drectangle& a
) { return a.area(); }
inline drectangle centered_drect (
const dlib::vector<double,2>& p,
const double& width,
const double& height
)
{
return drectangle(p.x()-width/2, p.y()-height/2, p.x()+width/2, p.y()+height/2);
}
// ----------------------------------------------------------------------------------------
}
#endif // DLIB_DRECTANGLe_
dlib/geometry/drectangle_abstract.h 0 → 100644
View file @ e0f7b41a
// Copyright (C) 2015 Davis E. King (davis@dlib.net)
// License: Boost Software License See LICENSE.txt for the full license.
#undef DLIB_DRECTANGLe_ABSTRACT_H_
#ifdef DLIB_DRECTANGLe_ABSTRACT_H_
#include "rectangle_abstract.h"
namespace dlib
{
// ----------------------------------------------------------------------------------------
class drectangle
{
/*!
INITIAL VALUE
The initial value of this object is defined by its constructor.
WHAT THIS OBJECT REPRESENTS
This object is just like dlib::rectangle except that it stores the
coordinates of the rectangle using double rather than long variables. As
such, this object represents a rectangular region inside a Cartesian
coordinate system. The region is the rectangle with its top left corner at
position (left(),top()) and its bottom right corner at (right(),bottom()).
Note that the origin of the coordinate system, i.e. (0,0), is located at
the upper left corner. That is, points such as (1,1) or (3,5) represent
locations that are below and to the right of the origin.
Also note that rectangles where top() > bottom() or left() > right()
represent empty rectangles.
!*/
public:
drectangle (
);
/*!
ensures
- #left() == 0
- #top() == 0
- #right() == -1
- #bottom() == -1
- #is_empty() == true
!*/
drectangle (
double left_,
double top_,
double right_,
double bottom_
);
/*!
ensures
- #left() == left_
- #top() == top_
- #right() == right_
- #bottom() == bottom_
!*/
drectangle (
const vector<double,2>& p
);
/*!
ensures
- #left() == p.x()
- #top() == p.y()
- #right() == p.x()
- #bottom() == p.y()
!*/
template <typename T, typename U>
drectangle (
const vector<T,2>& p1,
const vector<U,2>& p2
);
/*!
ensures
- #*this == drectangle(p1) + drectangle(p2)
!*/
drectangle (
const drectangle& rect
);
/*!
ensures
- #*this represents the same rectangle as rect
!*/
drectangle (
const rectangle& rect
);
/*!
ensures
- left() == rect.left()
- top() == rect.top()
- right() == rect.right()
- bottom() == rect.bottom()
!*/
operator rectangle (
) const;
/*!
ensures
- rounds the left, top, right, and bottom coordinates of *this to the
nearest integers and returns the resulting rectangle.
!*/
double left (
) const;
/*!
ensures
- returns the x coordinate for the left side of this rectangle
!*/
double& left (
);
/*!
ensures
- returns a non-const reference to the x coordinate for the left side
of this rectangle
!*/
double top (
) const;
/*!
ensures
- returns the y coordinate for the top of this rectangle
!*/
double& top (
);
/*!
ensures
- returns a non-const reference to the y coordinate for the
top of this rectangle
!*/
double right (
) const;
/*!
ensures
- returns the x coordinate for the right side of this rectangle
!*/
double& right (
);
/*!
ensures
- returns a non-const reference to the x coordinate for the right
side of this rectangle
!*/
double bottom (
) const;
/*!
ensures
- returns the y coordinate for the bottom of this rectangle
!*/
double& bottom (
);
/*!
ensures
- returns a non-const reference to the y coordinate for the bottom
of this rectangle
!*/
const vector<double,2> tl_corner (
) const;
/*!
ensures
- returns vector<double,2>(left(), top())
(i.e. returns the top left corner point for this rectangle)
!*/
const vector<double,2> bl_corner (
) const;
/*!
ensures
- returns vector<double,2>(left(), bottom())
(i.e. returns the bottom left corner point for this rectangle)
!*/
const vector<double,2> tr_corner (
) const;
/*!
ensures
- returns vector<double,2>(right(), top())
(i.e. returns the top right corner point for this rectangle)
!*/
const vector<double,2> br_corner (
) const;
/*!
ensures
- returns vector<double,2>(right(), bottom())
(i.e. returns the bottom right corner point for this rectangle)
!*/
double width (
) const;
/*!
ensures
- if (is_empty()) then
- returns 0
- else
- returns the width of this rectangle.
(i.e. right() - left())
!*/
double height (
) const;
/*!
ensures
- if (is_empty()) then
- returns 0
- else
- returns the height of this rectangle.
(i.e. bottom() - top())
!*/
double area (
) const;
/*!
ensures
- returns width()*height()
!*/
bool is_empty (
) const;
/*!
ensures
- if (top() > bottom() || left() > right()) then
- returns true
- else
- returns false
!*/
drectangle operator + (
const drectangle& rhs
) const;
/*!
ensures
- if (rhs.is_empty() == false && this->is_empty() == false) then
- returns the smallest rectangle that contains both *this and
rhs.
- if (rhs.is_empty() == true && this->is_empty() == false) then
- returns *this
- if (rhs.is_empty() == false && this->is_empty() == true) then
- returns rhs
- if (rhs.is_empty() == true && this->is_empty() == true) then
- returns a rectangle that has is_empty() == true
!*/
drectangle intersect (
const drectangle& rhs
) const;
/*!
ensures
- if (there is a region of intersection between *this and rhs) then
- returns a rectangle that represents the intersection of *this
and rhs.
- else
- returns a rectangle where is_empty() == true
!*/
bool contains (
const vector<double,2>& p
) const;
/*!
ensures
- if (the point (p.x(),p.y()) is contained in this rectangle) then
- returns true
- else
- returns false
!*/
bool contains (
const drectangle& rect
) const
/*!
ensures
- if (rect + *this == *this) then
- returns true
(i.e. returns true if *this contains the given rectangle)
- else
- returns false
!*/
drectangle& operator *= (
const double& scale
);
/*!
ensures
- performs: *this = *this*scale;
- returns #*this
!*/
drectangle& operator /= (
const double& scale
);
/*!
requires
- scale != 0
ensures
- performs: *this = *this*(1.0/scale);
- returns #*this
!*/
};
// ----------------------------------------------------------------------------------------
void serialize (
const drectangle& item,
std::ostream& out
);
/*!
provides serialization support
!*/
void deserialize (
drectangle& item,
std::istream& in
);
/*!
provides deserialization support
!*/
// ----------------------------------------------------------------------------------------
std::ostream& operator<< (
std::ostream& out,
const drectangle& item
);
/*!
ensures
- writes item to out in the form "[(left, top) (right, bottom)]"
!*/
// ----------------------------------------------------------------------------------------
std::istream& operator>>(
std::istream& in,
drectangle& item
);
/*!
ensures
- reads a drectangle from the input stream in and stores it in #item. The data
in the input stream should be of the form [(left, top) (right, bottom)]
!*/
// ----------------------------------------------------------------------------------------
vector<double,2> center (
const drectangle& rect
);
/*!
ensures
- returns the center of the given rectangle
!*/
// ----------------------------------------------------------------------------------------
vector<double,2> dcenter (
const drectangle& rect
);
/*!
ensures
- returns the center of the given rectangle. (Both center() and dcenter() are
identical when applied to drectangle objects)
!*/
// ----------------------------------------------------------------------------------------
drectangle operator* (
const drectangle& rect,
const double& scale
);
/*!
ensures
- This function returns a rectangle that has the same center as rect but with a
width and height that are scale times larger. That is, we return a new
rectangle R such that:
- center(R) == center(rect)
- R.width() == rect.width()*scale
- R.height() == rect.height()*scale
!*/
// ----------------------------------------------------------------------------------------
drectangle operator* (
const double& scale,
const drectangle& rect
);
/*!
ensures
- returns rect*scale
!*/
// ----------------------------------------------------------------------------------------
drectangle operator/ (
const drectangle& rect,
const double& scale
);
/*!
ensures
- returns rect*(1.0/scale)
!*/
// ----------------------------------------------------------------------------------------
drectangle operator+ (
const drectangle& r,
const vector<double,2>& p
);
/*!
ensures
- returns r + drectangle(p)
(i.e. returns the rectangle that contains both r and p)
!*/
// ----------------------------------------------------------------------------------------
drectangle operator+ (
const vector<double,2>& p,
const drectangle& r
);
/*!
ensures
- returns r + drectangle(p)
(i.e. returns the rectangle that contains both r and p)
!*/
// ----------------------------------------------------------------------------------------
drectangle translate_rect (
const drectangle& rect,
const vector<double,2>& p
);
/*!
ensures
- returns a rectangle R such that:
- R.left() == rect.left() + p.x()
- R.right() == rect.right() + p.x()
- R.top() == rect.top() + p.y()
- R.bottom() == rect.bottom() + p.y()
!*/
// ----------------------------------------------------------------------------------------
drectangle intersect (
const drectangle& a,
const drectangle& b
);
/*!
ensures
- returns a.intersect(b)
(i.e. returns a rectangle representing the intersection of a and b)
!*/
// ----------------------------------------------------------------------------------------
double area (
const drectangle& a
);
/*!
ensures
- returns a.area()
!*/
// ----------------------------------------------------------------------------------------
drectangle centered_drect (
const vector<double,2>& p,
const double& width,
const double& height
);
/*!
ensures
- returns a rectangle R such that:
- center(R) == p
- if (width == 0 || height == 0)
- R.width() == 0
- R.height() == 0
- else
- R.width() == width
- R.height() == height
- R.tl_corner() == point(p.x()-width/2, p.y()-height/2)
!*/
// ----------------------------------------------------------------------------------------
}
#endif // DLIB_DRECTANGLe_ABSTRACT_H_
dlib/image_transforms/image_pyramid.h
View file @ e0f7b41a
...@@ -62,36 +62,36 @@ namespace dlib ...@@ -62,36 +62,36 @@ namespace dlib
// ----------------------------- // -----------------------------
rectangle rect_up ( drectangle rect_up (
const rectangle& rect const drectangle& rect
) const ) const
{ {
return rectangle(point_up(rect.tl_corner()), point_up(rect.br_corner())); return drectangle(point_up(rect.tl_corner()), point_up(rect.br_corner()));
} }
rectangle rect_up ( drectangle rect_up (
const rectangle& rect, const drectangle& rect,
unsigned int levels unsigned int levels
) const ) const
{ {
return rectangle(point_up(rect.tl_corner(),levels), point_up(rect.br_corner(),levels)); return drectangle(point_up(rect.tl_corner(),levels), point_up(rect.br_corner(),levels));
} }
// ----------------------------- // -----------------------------
rectangle rect_down ( drectangle rect_down (
const rectangle& rect const drectangle& rect
) const ) const
{ {
return rectangle(point_down(rect.tl_corner()), point_down(rect.br_corner())); return drectangle(point_down(rect.tl_corner()), point_down(rect.br_corner()));
} }
rectangle rect_down ( drectangle rect_down (
const rectangle& rect, const drectangle& rect,
unsigned int levels unsigned int levels
) const ) const
{ {
return rectangle(point_down(rect.tl_corner(),levels), point_down(rect.br_corner(),levels)); return drectangle(point_down(rect.tl_corner(),levels), point_down(rect.br_corner(),levels));
} }
// ----------------------------- // -----------------------------
...@@ -196,36 +196,36 @@ namespace dlib ...@@ -196,36 +196,36 @@ namespace dlib
// ----------------------------- // -----------------------------
rectangle rect_up ( drectangle rect_up (
const rectangle& rect const drectangle& rect
) const ) const
{ {
return rectangle(point_up(rect.tl_corner()), point_up(rect.br_corner())); return drectangle(point_up(rect.tl_corner()), point_up(rect.br_corner()));
} }
rectangle rect_up ( drectangle rect_up (
const rectangle& rect, const drectangle& rect,
unsigned int levels unsigned int levels
) const ) const
{ {
return rectangle(point_up(rect.tl_corner(),levels), point_up(rect.br_corner(),levels)); return drectangle(point_up(rect.tl_corner(),levels), point_up(rect.br_corner(),levels));
} }
// ----------------------------- // -----------------------------
rectangle rect_down ( drectangle rect_down (
const rectangle& rect const drectangle& rect
) const ) const
{ {
return rectangle(point_down(rect.tl_corner()), point_down(rect.br_corner())); return drectangle(point_down(rect.tl_corner()), point_down(rect.br_corner()));
} }
rectangle rect_down ( drectangle rect_down (
const rectangle& rect, const drectangle& rect,
unsigned int levels unsigned int levels
) const ) const
{ {
return rectangle(point_down(rect.tl_corner(),levels), point_down(rect.br_corner(),levels)); return drectangle(point_down(rect.tl_corner(),levels), point_down(rect.br_corner(),levels));
} }
// ----------------------------- // -----------------------------
...@@ -538,36 +538,36 @@ namespace dlib ...@@ -538,36 +538,36 @@ namespace dlib
// ----------------------------- // -----------------------------
rectangle rect_up ( drectangle rect_up (
const rectangle& rect const drectangle& rect
) const ) const
{ {
return rectangle(point_up(rect.tl_corner()), point_up(rect.br_corner())); return drectangle(point_up(rect.tl_corner()), point_up(rect.br_corner()));
} }
rectangle rect_up ( drectangle rect_up (
const rectangle& rect, const drectangle& rect,
unsigned int levels unsigned int levels
) const ) const
{ {
return rectangle(point_up(rect.tl_corner(),levels), point_up(rect.br_corner(),levels)); return drectangle(point_up(rect.tl_corner(),levels), point_up(rect.br_corner(),levels));
} }
// ----------------------------- // -----------------------------
rectangle rect_down ( drectangle rect_down (
const rectangle& rect const drectangle& rect
) const ) const
{ {
return rectangle(point_down(rect.tl_corner()), point_down(rect.br_corner())); return drectangle(point_down(rect.tl_corner()), point_down(rect.br_corner()));
} }
rectangle rect_down ( drectangle rect_down (
const rectangle& rect, const drectangle& rect,
unsigned int levels unsigned int levels
) const ) const
{ {
return rectangle(point_down(rect.tl_corner(),levels), point_down(rect.br_corner(),levels)); return drectangle(point_down(rect.tl_corner(),levels), point_down(rect.br_corner(),levels));
} }
// ----------------------------- // -----------------------------
...@@ -889,36 +889,36 @@ namespace dlib ...@@ -889,36 +889,36 @@ namespace dlib
// ----------------------------- // -----------------------------
rectangle rect_up ( drectangle rect_up (
const rectangle& rect const drectangle& rect
) const ) const
{ {
return rectangle(point_up(rect.tl_corner()), point_up(rect.br_corner())); return drectangle(point_up(rect.tl_corner()), point_up(rect.br_corner()));
} }
rectangle rect_up ( drectangle rect_up (
const rectangle& rect, const drectangle& rect,
unsigned int levels unsigned int levels
) const ) const
{ {
return rectangle(point_up(rect.tl_corner(),levels), point_up(rect.br_corner(),levels)); return drectangle(point_up(rect.tl_corner(),levels), point_up(rect.br_corner(),levels));
} }
// ----------------------------- // -----------------------------
rectangle rect_down ( drectangle rect_down (
const rectangle& rect const drectangle& rect
) const ) const
{ {
return rectangle(point_down(rect.tl_corner()), point_down(rect.br_corner())); return drectangle(point_down(rect.tl_corner()), point_down(rect.br_corner()));
} }
rectangle rect_down ( drectangle rect_down (
const rectangle& rect, const drectangle& rect,
unsigned int levels unsigned int levels
) const ) const
{ {
return rectangle(point_down(rect.tl_corner(),levels), point_down(rect.br_corner(),levels)); return drectangle(point_down(rect.tl_corner(),levels), point_down(rect.br_corner(),levels));
} }
template < template <
......
dlib/image_transforms/image_pyramid_abstract.h
View file @ e0f7b41a
...@@ -109,21 +109,21 @@ namespace dlib ...@@ -109,21 +109,21 @@ namespace dlib
point_up(point_down(P)) == P point_up(point_down(P)) == P
!*/ !*/
rectangle rect_down ( drectangle rect_down (
const rectangle& rect const drectangle& rect
) const; ) const;
/*! /*!
ensures ensures
- returns rectangle(point_down(rect.tl_corner()), point_down(rect.br_corner())); - returns drectangle(point_down(rect.tl_corner()), point_down(rect.br_corner()));
(i.e. maps rect into a downsampled) (i.e. maps rect into a downsampled)
!*/ !*/
rectangle rect_up ( drectangle rect_up (
const rectangle& rect const drectangle& rect
) const; ) const;
/*! /*!
ensures ensures
- returns rectangle(point_up(rect.tl_corner()), point_up(rect.br_corner())); - returns drectangle(point_up(rect.tl_corner()), point_up(rect.br_corner()));
(i.e. maps rect into a parent image) (i.e. maps rect into a parent image)
!*/ !*/
...@@ -155,23 +155,23 @@ namespace dlib ...@@ -155,23 +155,23 @@ namespace dlib
point_up(p,0) == p, etc. ) point_up(p,0) == p, etc. )
!*/ !*/
rectangle rect_down ( drectangle rect_down (
const rectangle& rect, const drectangle& rect,
unsigned int levels unsigned int levels
) const; ) const;
/*! /*!
ensures ensures
- returns rectangle(point_down(rect.tl_corner(),levels), point_down(rect.br_corner(),levels)); - returns drectangle(point_down(rect.tl_corner(),levels), point_down(rect.br_corner(),levels));
(i.e. Basically applies rect_down() to rect levels times and returns the result.) (i.e. Basically applies rect_down() to rect levels times and returns the result.)
!*/ !*/
rectangle rect_up ( drectangle rect_up (
const rectangle& rect, const drectangle& rect,
unsigned int levels unsigned int levels
) const; ) const;
/*! /*!
ensures ensures
- returns rectangle(point_up(rect.tl_corner(),levels), point_up(rect.br_corner(),levels)); - returns drectangle(point_up(rect.tl_corner(),levels), point_up(rect.br_corner(),levels));
(i.e. Basically applies rect_up() to rect levels times and returns the result.) (i.e. Basically applies rect_up() to rect levels times and returns the result.)
!*/ !*/
......
dlib/image_transforms/interpolation.h
View file @ e0f7b41a
...@@ -1426,15 +1426,15 @@ namespace dlib ...@@ -1426,15 +1426,15 @@ namespace dlib
struct chip_details struct chip_details
{ {
chip_details() : angle(0), rows(0), cols(0) {} chip_details() : angle(0), rows(0), cols(0) {}
chip_details(const rectangle& rect_) : rect(rect_),angle(0), rows(rect_.height()), cols(rect_.width()) {} chip_details(const drectangle& rect_) : rect(rect_),angle(0), rows(rect_.height()), cols(rect_.width()) {}
chip_details(const rectangle& rect_, unsigned long size) : rect(rect_),angle(0) chip_details(const drectangle& rect_, unsigned long size) : rect(rect_),angle(0)
{ compute_dims_from_size(size); } { compute_dims_from_size(size); }
chip_details(const rectangle& rect_, unsigned long size, double angle_) : rect(rect_),angle(angle_) chip_details(const drectangle& rect_, unsigned long size, double angle_) : rect(rect_),angle(angle_)
{ compute_dims_from_size(size); } { compute_dims_from_size(size); }
chip_details(const rectangle& rect_, const chip_dims& dims) : chip_details(const drectangle& rect_, const chip_dims& dims) :
rect(rect_),angle(0),rows(dims.rows), cols(dims.cols) {} rect(rect_),angle(0),rows(dims.rows), cols(dims.cols) {}
chip_details(const rectangle& rect_, const chip_dims& dims, double angle_) : chip_details(const drectangle& rect_, const chip_dims& dims, double angle_) :
rect(rect_),angle(angle_),rows(dims.rows), cols(dims.cols) {} rect(rect_),angle(angle_),rows(dims.rows), cols(dims.cols) {}
template <typename T> template <typename T>
...@@ -1463,13 +1463,13 @@ namespace dlib ...@@ -1463,13 +1463,13 @@ namespace dlib
// Note that the translation and scale part are represented by the extraction // Note that the translation and scale part are represented by the extraction
// rectangle. So here we build the appropriate rectangle. // rectangle. So here we build the appropriate rectangle.
const double scale = length(p); const double scale = length(p);
rect = centered_rect(tform(point(dims.cols,dims.rows)/2.0), rect = centered_drect(tform(point(dims.cols,dims.rows)/2.0),
static_cast<unsigned long>(dims.cols*scale + 0.5), dims.cols*scale,
static_cast<unsigned long>(dims.rows*scale + 0.5)); dims.rows*scale);
} }
rectangle rect; drectangle rect;
double angle; double angle;
unsigned long rows; unsigned long rows;
unsigned long cols; unsigned long cols;
...@@ -1611,7 +1611,7 @@ namespace dlib ...@@ -1611,7 +1611,7 @@ namespace dlib
for (unsigned long i = 0; i < chip_locations.size(); ++i) for (unsigned long i = 0; i < chip_locations.size(); ++i)
{ {
long depth = 0; long depth = 0;
rectangle rect = pyr.rect_down(chip_locations[i].rect); drectangle rect = pyr.rect_down(chip_locations[i].rect);
while (rect.area() > chip_locations[i].size()) while (rect.area() > chip_locations[i].size())
{ {
rect = pyr.rect_down(rect); rect = pyr.rect_down(rect);
...@@ -1647,7 +1647,7 @@ namespace dlib ...@@ -1647,7 +1647,7 @@ namespace dlib
// figure out which level in the pyramid to use to extract the chip // figure out which level in the pyramid to use to extract the chip
int level = -1; int level = -1;
rectangle rect = chip_locations[i].rect; drectangle rect = chip_locations[i].rect;
while (pyr.rect_down(rect).area() > chip_locations[i].size()) while (pyr.rect_down(rect).area() > chip_locations[i].size())
{ {
++level; ++level;
......
dlib/image_transforms/interpolation_abstract.h
View file @ e0f7b41a
...@@ -923,7 +923,7 @@ namespace dlib ...@@ -923,7 +923,7 @@ namespace dlib
!*/ !*/
chip_details( chip_details(
const rectangle& rect_ const drectangle& rect_
); );
/*! /*!
ensures ensures
...@@ -935,7 +935,7 @@ namespace dlib ...@@ -935,7 +935,7 @@ namespace dlib
!*/ !*/
chip_details( chip_details(
const rectangle& rect_, const drectangle& rect_,
unsigned long size_ unsigned long size_
); );
/*! /*!
...@@ -956,7 +956,7 @@ namespace dlib ...@@ -956,7 +956,7 @@ namespace dlib
!*/ !*/
chip_details( chip_details(
const rectangle& rect_, const drectangle& rect_,
unsigned long size_, unsigned long size_,
double angle_ double angle_
); );
...@@ -978,7 +978,7 @@ namespace dlib ...@@ -978,7 +978,7 @@ namespace dlib
!*/ !*/
chip_details( chip_details(
const rectangle& rect_, const drectangle& rect_,
const chip_dims& dims const chip_dims& dims
); );
/*! /*!
...@@ -991,7 +991,7 @@ namespace dlib ...@@ -991,7 +991,7 @@ namespace dlib
!*/ !*/
chip_details( chip_details(
const rectangle& rect_, const drectangle& rect_,
const chip_dims& dims, const chip_dims& dims,
double angle_ double angle_
); );
...@@ -1034,7 +1034,7 @@ namespace dlib ...@@ -1034,7 +1034,7 @@ namespace dlib
- returns the number of pixels in this chip. This is just rows*cols. - returns the number of pixels in this chip. This is just rows*cols.
!*/ !*/
rectangle rect; drectangle rect;
double angle; double angle;
unsigned long rows; unsigned long rows;
unsigned long cols; unsigned long cols;
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment