generic-library/opencv
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

No longer expose internal LINE-MOD methods like response map computation, linearizing similarities, etc in public header.

Browse Source
This commit is contained in:
Patrick Mihelich 2012-02-27 00:07:52 +00:00
parent f174b001f3
commit f483272d09
2 changed files with 90 additions and 131 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

113
modules/objdetect/include/opencv2/objdetect/objdetect.hpp
View File

@ -679,37 +679,6 @@ using cv::Size;
/// @todo Convert doxy comments to rst
/// @todo Move stuff that doesn't need to be public into linemod.cpp
/**
* \brief Compute quantized orientation image from color image.
*
* Implements section 2.2 "Computing the Gradient Orientations."
*
* \param[in] src The source 8-bit, 3-channel image.
* \param[out] magnitude Destination floating-point array of squared magnitudes.
* \param[out] angle Destination 8-bit array of orientations. Each bit
* represents one bin of the orientation space.
* \param threshold Magnitude threshold. Keep only gradients whose norms are
* larger than this.
*/
void quantizedOrientations(const Mat& src, Mat& magnitude,
Mat& angle, float threshold);
/**
* \brief Compute quantized normal image from depth image.
*
* Implements section 2.6 "Extension to Dense Depth Sensors."
*
* \param[in] src The source 16-bit depth image (in mm).
* \param[out] dst The destination 8-bit image. Each bit represents one bin of
* the view cone.
* \param distance_threshold Ignore pixels beyond this distance.
* \param difference_threshold When computing normals, ignore contributions of pixels whose
* depth difference with the central pixel is above this threshold.
*
* \todo Should also need camera model, or at least focal lengths? Replace distance_threshold with mask?
*/
void quantizedNormals(const Mat& src, Mat& dst, int distance_threshold,
int difference_threshold = 50);
/**
* \brief Discriminant feature described by its location and label.
@ -738,15 +707,6 @@ struct Template
void write(FileStorage& fs) const;
};
/**
* \brief Crop a set of overlapping templates from different modalities.
*
* \param[in,out] templates Set of templates representing the same object view.
*
* \return The bounding box of all the templates in original image coordinates.
*/
Rect cropTemplates(std::vector<Template>& templates);
/**
* \brief Represents a modality operating over an image pyramid.
*/
@ -938,74 +898,6 @@ protected:
*/
void colormap(const Mat& quantized, Mat& dst);
/**
* \brief Spread binary labels in a quantized image.
*
* Implements section 2.3 "Spreading the Orientations."
*
* \param[in] src The source 8-bit quantized image.
* \param[out] dst Destination 8-bit spread image.
* \param T Sampling step. Spread labels T/2 pixels in each direction.
*/
void spread(const Mat& src, Mat& dst, int T);
/**
* \brief Precompute response maps for a spread quantized image.
*
* Implements section 2.4 "Precomputing Response Maps."
*
* \param[in] src The source 8-bit spread quantized image.
* \param[out] response_maps Vector of 8 response maps, one for each bit label.
*/
void computeResponseMaps(const Mat& src, std::vector<Mat>& response_maps);
/**
* \brief Convert a response map to fast linearized ordering.
*
* Implements section 2.5 "Linearizing the Memory for Parallelization."
*
* \param[in] response_map The 2D response map, an 8-bit image.
* \param[out] linearized The response map in linearized order. It has T*T rows,
* each of which is a linear memory of length (W/T)*(H/T).
* \param T Sampling step.
*/
void linearize(const Mat& response_map, Mat& linearized, int T);
/**
* \brief Compute similarity measure for a given template at each sampled image location.
*
* Uses linear memories to compute the similarity measure as described in Fig. 7.
*
* \param[in] linear_memories Vector of 8 linear memories, one for each label.
* \param[in] templ Template to match against.
* \param[out] dst Destination 8-bit similarity image of size (W/T, H/T).
* \param size Size (W, H) of the original input image.
* \param T Sampling step.
*/
void similarity(const std::vector<Mat>& linear_memories, const Template& templ,
Mat& dst, Size size, int T);
/**
* \brief Compute similarity measure for a given template in a local region.
*
* \param[in] linear_memories Vector of 8 linear memories, one for each label.
* \param[in] templ Template to match against.
* \param[out] dst Destination 8-bit similarity image, 16x16.
* \param size Size (W, H) of the original input image.
* \param T Sampling step.
* \param center Center of the local region.
*/
void similarityLocal(const std::vector<Mat>& linear_memories, const Template& templ,
Mat& dst, Size size, int T, Point center);
/**
* \brief Accumulate one or more 8-bit similarity images.
*
* \param[in] similarities Source 8-bit similarity images.
* \param[out] dst Destination 16-bit similarity image.
*/
void addSimilarities(const std::vector<Mat>& similarities, Mat& dst);
/**
* \brief Represents a successful template match.
*/
@ -1060,10 +952,8 @@ public:
* \param modalities Modalities to use (color gradients, depth normals, ...).
* \param T_pyramid Value of the sampling step T at each pyramid level. The
* number of pyramid levels is T_pyramid.size().
* \param pyramid_distance Scale factor between pyramid levels.
*/
Detector(const std::vector< Ptr<Modality> >& modalities,
const std::vector<int>& T_pyramid, double pyramid_distance = 2.0);
Detector(const std::vector< Ptr<Modality> >& modalities, const std::vector<int>& T_pyramid);
/**
* \brief Detect objects by template matching.
@ -1148,7 +1038,6 @@ public:
protected:
std::vector< Ptr<Modality> > modalities;
int pyramid_levels;
double pyramid_distance;
std::vector<int> T_at_level;
typedef std::vector<Template> TemplatePyramid;

108
modules/objdetect/src/linemod.cpp
View File

@ -84,6 +84,13 @@ void Feature::write(FileStorage& fs) const
// struct Template
/**
* \brief Crop a set of overlapping templates from different modalities.
*
* \param[in,out] templates Set of templates representing the same object view.
*
* \return The bounding box of all the templates in original image coordinates.
*/
Rect cropTemplates(std::vector<Template>& templates)
{
int min_x = std::numeric_limits<int>::max();
@ -246,7 +253,18 @@ void colormap(const Mat& quantized, Mat& dst)
void hysteresisGradient(Mat& magnitude, Mat& angle,
Mat& ap_tmp, float threshold);
// Implements section 2.2
/**
* \brief Compute quantized orientation image from color image.
*
* Implements section 2.2 "Computing the Gradient Orientations."
*
* \param[in] src The source 8-bit, 3-channel image.
* \param[out] magnitude Destination floating-point array of squared magnitudes.
* \param[out] angle Destination 8-bit array of orientations. Each bit
* represents one bin of the orientation space.
* \param threshold Magnitude threshold. Keep only gradients whose norms are
* larger than this.
*/
void quantizedOrientations(const Mat& src, Mat& magnitude,
Mat& angle, float threshold)
{
@ -598,6 +616,20 @@ static void accumBilateral(long delta, long i, long j, long * A, long * b, int t
b[1] += fj * delta;
}
/**
* \brief Compute quantized normal image from depth image.
*
* Implements section 2.6 "Extension to Dense Depth Sensors."
*
* \param[in] src The source 16-bit depth image (in mm).
* \param[out] dst The destination 8-bit image. Each bit represents one bin of
* the view cone.
* \param distance_threshold Ignore pixels beyond this distance.
* \param difference_threshold When computing normals, ignore contributions of pixels whose
* depth difference with the central pixel is above this threshold.
*
* \todo Should also need camera model, or at least focal lengths? Replace distance_threshold with mask?
*/
void quantizedNormals(const Mat& src, Mat& dst, int distance_threshold,
int difference_threshold)
{
@ -948,6 +980,15 @@ void orUnaligned8u(const uchar * src, const int src_stride,
}
}
/**
* \brief Spread binary labels in a quantized image.
*
* Implements section 2.3 "Spreading the Orientations."
*
* \param[in] src The source 8-bit quantized image.
* \param[out] dst Destination 8-bit spread image.
* \param T Sampling step. Spread labels T/2 pixels in each direction.
*/
void spread(const Mat& src, Mat& dst, int T)
{
// Allocate and zero-initialize spread (OR'ed) image
@ -968,6 +1009,14 @@ void spread(const Mat& src, Mat& dst, int T)
// Auto-generated by create_similarity_lut.py
CV_DECL_ALIGNED(16) static const unsigned char SIMILARITY_LUT[256] = {0, 4, 3, 4, 2, 4, 3, 4, 1, 4, 3, 4, 2, 4, 3, 4, 0, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 0, 3, 4, 4, 3, 3, 4, 4, 2, 3, 4, 4, 3, 3, 4, 4, 0, 1, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 3, 3, 4, 4, 4, 4, 3, 3, 3, 3, 4, 4, 4, 4, 0, 2, 1, 2, 0, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 0, 3, 2, 3, 1, 3, 2, 3, 0, 3, 2, 3, 1, 3, 2, 3, 0, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 0, 4, 3, 4, 2, 4, 3, 4, 1, 4, 3, 4, 2, 4, 3, 4, 0, 1, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 0, 3, 4, 4, 3, 3, 4, 4, 2, 3, 4, 4, 3, 3, 4, 4, 0, 2, 1, 2, 0, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 0, 2, 3, 3, 4, 4, 4, 4, 3, 3, 3, 3, 4, 4, 4, 4, 0, 3, 2, 3, 1, 3, 2, 3, 0, 3, 2, 3, 1, 3, 2, 3, 0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4};
/**
* \brief Precompute response maps for a spread quantized image.
*
* Implements section 2.4 "Precomputing Response Maps."
*
* \param[in] src The source 8-bit spread quantized image.
* \param[out] response_maps Vector of 8 response maps, one for each bit label.
*/
void computeResponseMaps(const Mat& src, std::vector<Mat>& response_maps)
{
CV_Assert((src.rows * src.cols) % 16 == 0);
@ -1039,6 +1088,16 @@ void computeResponseMaps(const Mat& src, std::vector<Mat>& response_maps)
}
}
/**
* \brief Convert a response map to fast linearized ordering.
*
* Implements section 2.5 "Linearizing the Memory for Parallelization."
*
* \param[in] response_map The 2D response map, an 8-bit image.
* \param[out] linearized The response map in linearized order. It has T*T rows,
* each of which is a linear memory of length (W/T)*(H/T).
* \param T Sampling step.
*/
void linearize(const Mat& response_map, Mat& linearized, int T)
{
CV_Assert(response_map.rows % T == 0);
@ -1098,7 +1157,17 @@ const unsigned char* accessLinearMemory(const std::vector<Mat>& linear_memories,
return memory + lm_index;
}
// NOTE: Returning dst as uint8 instead of uint16
/**
* \brief Compute similarity measure for a given template at each sampled image location.
*
* Uses linear memories to compute the similarity measure as described in Fig. 7.
*
* \param[in] linear_memories Vector of 8 linear memories, one for each label.
* \param[in] templ Template to match against.
* \param[out] dst Destination 8-bit similarity image of size (W/T, H/T).
* \param size Size (W, H) of the original input image.
* \param T Sampling step.
*/
void similarity(const std::vector<Mat>& linear_memories, const Template& templ,
Mat& dst, Size size, int T)
{
@ -1183,7 +1252,16 @@ void similarity(const std::vector<Mat>& linear_memories, const Template& templ,
}
}
// NOTE: Returning dst as uint8 instead of uint16
/**
* \brief Compute similarity measure for a given template in a local region.
*
* \param[in] linear_memories Vector of 8 linear memories, one for each label.
* \param[in] templ Template to match against.
* \param[out] dst Destination 8-bit similarity image, 16x16.
* \param size Size (W, H) of the original input image.
* \param T Sampling step.
* \param center Center of the local region.
*/
void similarityLocal(const std::vector<Mat>& linear_memories, const Template& templ,
Mat& dst, Size size, int T, Point center)
{
@ -1272,6 +1350,12 @@ void addUnaligned8u16u(const uchar * src1, const uchar * src2, ushort * res, int
}
}
/**
* \brief Accumulate one or more 8-bit similarity images.
*
* \param[in] similarities Source 8-bit similarity images.
* \param[out] dst Destination 16-bit similarity image.
*/
void addSimilarities(const std::vector<Mat>& similarities, Mat& dst)
{
if (similarities.size() == 1)
@ -1299,13 +1383,11 @@ Detector::Detector()
}
Detector::Detector(const std::vector< Ptr<Modality> >& modalities,
const std::vector<int>& T_pyramid, double pyramid_distance)
const std::vector<int>& T_pyramid)
: modalities(modalities),
pyramid_levels(T_pyramid.size()),
pyramid_distance(pyramid_distance),
T_at_level(T_pyramid)
{
CV_Assert(pyramid_distance == 2.0);
}
void Detector::match(const std::vector<Mat>& sources, float threshold, std::vector<Match>& matches,
@ -1397,13 +1479,6 @@ struct MatchPredicate
float threshold;
};
bool non_negative_assert(const Template& templ)
{
for(size_t j = 0; j < templ.features.size(); ++j)
assert(templ.features[j].x >= 0 && templ.features[j].y >= 0);
return true;
}
void Detector::matchClass(const LinearMemoryPyramid& lm_pyramid,
const std::vector<Size>& sizes,
float threshold, std::vector<Match>& matches,
@ -1478,7 +1553,7 @@ void Detector::matchClass(const LinearMemoryPyramid& lm_pyramid,
for (int m = 0; m < (int)candidates.size(); ++m)
{
Match& match = candidates[m];
int x = match.x * 2 + 1; /// @todo Support other pyramid_distance
int x = match.x * 2 + 1; /// @todo Support other pyramid distance
int y = match.y * 2 + 1;
// Require 8 (reduced) row/cols to the up/left
@ -1617,7 +1692,6 @@ void Detector::read(const FileNode& fn)
{
class_templates.clear();
pyramid_levels = fn["pyramid_levels"];
pyramid_distance = fn["pyramid_distance"];
fn["T"] >> T_at_level;
modalities.clear();
@ -1632,7 +1706,6 @@ void Detector::read(const FileNode& fn)
void Detector::write(FileStorage& fs) const
{
fs << "pyramid_levels" << pyramid_levels;
fs << "pyramid_distance" << pyramid_distance;
fs << "T" << "[:" << T_at_level << "]";
fs << "modalities" << "[";
@ -1655,7 +1728,6 @@ void Detector::write(FileStorage& fs) const
for ( ; mod_it != mod_it_end; ++mod_it, ++i)
CV_Assert(modalities[i]->name() == (std::string)(*mod_it));
CV_Assert((int)fn["pyramid_levels"] == pyramid_levels);
CV_Assert((int)fn["pyramid_distance"] == pyramid_distance);
// Detector should not already have this class
std::string class_id;
@ -1708,7 +1780,6 @@ void Detector::writeClass(const std::string& class_id, FileStorage& fs) const
fs << modalities[i]->name();
fs << "]"; // modalities
fs << "pyramid_levels" << pyramid_levels;
fs << "pyramid_distance" << pyramid_distance;
fs << "template_pyramids" << "[";
for (size_t i = 0; i < tps.size(); ++i)
{
@ -1752,7 +1823,6 @@ void Detector::writeClasses(const std::string& format) const
}
}
static const int T_DEFAULTS[] = {5, 8};
Ptr<Detector> getDefaultLINE()