Classes | |
| struct | f_invert |
| Fctor to invert a value. More... | |
| class | hlut |
| Look up table "id" version. More... | |
| class | hlut_def |
| Look up table "default" version. More... | |
| class | threshold |
| Threshold the value of the image. More... | |
Functions | |
| template<class DestType, class I, class E> mute< I, DestType >::ret | frontp_connected_component (const abstract::binary_image< I > &input, const abstract::neighborhood< E > &se, unsigned &nb_label) |
| Processing frontp_connected_component extract the connected components. | |
| template<class DestType, class I, class E> mute< I, DestType >::ret | frontp_connected_component (const abstract::image< I > &input, const abstract::neighborhood< E > &se) |
| template<class I> mute< I, ntg::bin >::ret | extract_i_cc (const abstract::image< I > &input, typename mlc::exact< I >::ret::value_type i) |
| template<class I> mlc::exact< I >::ret::value_type | get_n_cc (const abstract::image< I > &input) |
| template<class I1, class I2> bool | is_greater_or_equal (const abstract::image< I1 > &input1, const abstract::image< I2 > &input2) |
| Tests if all pixels of input1 are greater or equal than input2. | |
| template<class I1, class I2> bool | is_greater (const abstract::image< I1 > &input1, const abstract::image< I2 > &input2) |
| Tests if all pixels of input1 are greater than input2. | |
| template<class I1, class I2> bool | is_lower_or_equal (const abstract::image< I1 > &input1, const abstract::image< I2 > &input2) |
| Tests if all pixels of input1 are lower or equal than input2. | |
| template<class I1, class I2> bool | is_lower (const abstract::image< I1 > &input1, const abstract::image< I2 > &input2) |
| Tests if all pixel of input1 are lower than input2. | |
| template<class I1, class I2> bool | is_equal (const abstract::image< I1 > &input1, const abstract::image< I2 > &input2) |
| Tests if input1 is equal to input2. | |
| template<class DestType, class I, class N> mute< I, DestType >::ret | connected_component (const abstract::binary_image_with_dim< 2, I > &input, const abstract::neighborhood< N > &Ng) |
| template<class I> oln::mute< I >::ret | fill (abstract::image< I > &im, const typename mlc::exact< I >::ret::value_type &val) |
| Fill the image with a value. | |
| template<class I> oln::mute< I >::ret | invert (const abstract::image< I > &input) |
| Return the image inverted. | |
| template<class I> void | invert_self (abstract::image< I > &input) |
| Invert an image. | |
| template<class I> void | set_level (abstract::image_with_dim< 2, I > &inout, const typename mlc::exact< I >::ret::point_type &p1, const typename mlc::exact< I >::ret::point_type &p2, typename mlc::exact< I >::ret::value_type level) |
| Draw a line between two points in the image. | |
| template<class I, class BoxType> void | set_level (abstract::image_with_dim< 2, I > &inout, BoxType &box, const typename mlc::exact< I >::ret::value_type &level) |
|
||||||||||||||||||||
|
Processing frontp_connected_component extract the connected components. It removes the small (in area) connected components of the upper level sets of input using se as structural element. REF: The implementation uses front propagation.
Definition at line 96 of file cc.hh. References oln::abstract::image< Exact >::hold(), and oln::abstract::image< Exact >::size().
00099 {
00100 typename mute<I, DestType>::ret output(input.size());
00101 level::fill(output, 0);
00102
00103 typedef std::set<oln_point_type(I),
00104 oln::internal::default_less<oln_point_type(I) > >
00105 points_set;
00106
00107 I is_processed(input.size());
00108 level::fill(is_processed, false);
00109 DestType cur_label = 1;
00110 oln_iter_type(I) p(input);
00111 for_all(p) if ((input[p] == true)&& (is_processed[p] == false))
00112 {
00113 //propagation front
00114 points_set component;
00115 component.insert(p.cur());
00116 points_set points_to_process;
00117 points_to_process.insert(p.cur());
00118 while (!points_to_process.empty())
00119 {
00120 //set label and net neighbors
00121 points_set next;
00122 for (typename points_set::const_iterator i =
00123 points_to_process.begin();
00124 i != points_to_process.end();
00125 ++i)
00126 {
00127 component.insert(*i);
00128 oln_neighb_type(E) p_prime(se, *i);
00129 for_all (p_prime) if(input.hold(p_prime) &&
00130 (input[p_prime] == true))
00131 next.insert(p_prime.cur());
00132 }
00133 points_to_process.clear();
00134 set_difference(next.begin(), next.end(),
00135 component.begin(), component.end(),
00136 inserter(points_to_process,
00137 points_to_process.begin()),
00138 oln::internal::default_less<oln_point_type(I) >());
00139 }
00140 for (typename points_set::const_iterator i = component.begin();
00141 i != component.end();
00142 ++i)
00143 {
00144 output[*i] = cur_label;
00145 is_processed[*i] = true;
00146 }
00147 cur_label++;
00148 }
00149 nb_label = cur_label;
00150 return output;
00151 }
|
|
||||||||||||||||
|
Tests if input1 is equal to input2.
Definition at line 112 of file compare.hh. References oln::abstract::image< Exact >::size().
00114 {
00115 precondition(input1.size() == input2.size());
00116 oln_iter_type(I1) p(input1);
00117 for_all (p)
00118 if (!(input1[p] == input2[p]))
00119 return false;
00120 return true;
00121 }
|
|
||||||||||||||||
|
Tests if all pixels of input1 are greater than input2.
Definition at line 60 of file compare.hh. References oln::abstract::image< Exact >::size().
00062 {
00063 precondition(input1.size() == input2.size());
00064 oln_iter_type(I1) p(input1);
00065 for_all (p)
00066 if (!(input1[p] > input2[p]))
00067 return false;
00068 return true;
00069 }
|
|
||||||||||||||||
|
Tests if all pixels of input1 are greater or equal than input2.
Definition at line 43 of file compare.hh. References oln::abstract::image< Exact >::size().
00045 {
00046 precondition(input1.size() == input2.size());
00047 oln_iter_type(I1) p(input1);
00048 for_all (p)
00049 if (!(input1[p] >= input2[p]))
00050 return false;
00051 return true;
00052 }
|
|
||||||||||||||||
|
Tests if all pixel of input1 are lower than input2.
Definition at line 94 of file compare.hh. References oln::abstract::image< Exact >::size().
00096 {
00097 precondition(input1.size() == input2.size());
00098 oln_iter_type(I1) p(input1);
00099 for_all (p)
00100 if (!(input1[p] < input2[p]))
00101 return false;
00102 return true;
00103 }
|
|
||||||||||||||||
|
Tests if all pixels of input1 are lower or equal than input2.
Definition at line 77 of file compare.hh. References oln::abstract::image< Exact >::size().
00079 {
00080 precondition(input1.size() == input2.size());
00081 oln_iter_type(I1) p(input1);
00082 for_all (p)
00083 if (!(input1[p] <= input2[p]))
00084 return false;
00085 return true;
00086 }
|
|
||||||||||||||||||||
|
Draw a box in the image.
Definition at line 141 of file set_level.hh. References set_level().
00144 {
00145 if (box.card() != 0)
00146 {
00147 dpoint2d drows(box.top().row() - box.bottom().row(), 0);
00148 dpoint2d dcols(0, box.top().col() - box.bottom().col());
00149 set_level(inout, box.top(), box.top() - drows, level);
00150 set_level(inout, box.top(), box.top() - dcols, level);
00151 set_level(inout, box.bottom(), box.bottom() + drows, level);
00152 set_level(inout, box.bottom(), box.bottom() + dcols, level);
00153 }
00154 }
|
|
||||||||||||||||||||||||
|
Draw a line between two points in the image.
Definition at line 83 of file set_level.hh. Referenced by set_level().
00087 {
00088 int iRow1 = p1.row();
00089 int iCol1 = p1.col();
00090 int iRow2 = p2.row();
00091 int iCol2 = p2.col();
00092 int dRow = ( iRow2 > iRow1 ? iRow2 - iRow1 : iRow1 - iRow2 );
00093 int ddRow = 2 * dRow;
00094 int dCol = ( iCol2 > iCol1 ? iCol2 - iCol1 : iCol1 - iCol2 );
00095 int ddCol = 2 * dCol;
00096 int sRow = ( iRow2 != iRow1 ? ( iRow2 > iRow1 ? 1 : -1 ) : 0 );
00097 int sCol = ( iCol2 != iCol1 ? ( iCol2 > iCol1 ? 1 : -1 ) : 0 );
00098 int i, e;
00099 int iRow = iRow1;
00100 int iCol = iCol1;
00101
00102 if ( dCol > dRow )
00103 {
00104 e = ddRow - dCol;
00105 for ( i = 0; i < dCol; ++i )
00106 {
00107 inout(iRow, iCol) = level;
00108 while ( e >= 0 )
00109 {
00110 iRow += sRow;
00111 e -= ddCol;
00112 }
00113 iCol += sCol;
00114 e += ddRow;
00115 }
00116 }
00117 else
00118 {
00119 e = ddCol - dRow;
00120 for ( i = 0; i < dRow; ++i )
00121 {
00122 inout(iRow,iCol) = level;
00123 while ( e >= 0 )
00124 {
00125 iCol += sCol;
00126 e -= ddRow;
00127 }
00128 iRow += sRow;
00129 e += ddCol;
00130 }
00131 }
00132 inout(iRow,iCol) = level;
00133 }
|
1.3.6-20040222