smallest_rectangle2SmallestRectangle2SmallestRectangle2smallest_rectangle2smallest_rectangle2🔗

Short description🔗

smallest_rectangle2SmallestRectangle2SmallestRectangle2smallest_rectangle2smallest_rectangle2 — Smallest surrounding rectangle with any orientation.

Signature🔗

smallest_rectangle2( region Regions, out rectangle2.center.y Row, out rectangle2.center.x Column, out rectangle2.angle.rad Phi, out rectangle2.hwidth Length1, out rectangle2.hheight Length2 )

Description🔗

The operator smallest_rectangle2SmallestRectangle2 determines the smallest surrounding rectangle of a region, i.e., the rectangle with the smallest area of all rectangles containing the region. For this rectangle the center, the inclination and the two radii are calculated. The calculation of the rectangle is based on the center coordinates of the region pixels.

In the documentation of this chapter (Regions / Features), you can find an image illustrating regions which vary in the length and phi of their smallest surrounding rectangle.

The smallest surrounding rectangle of a region. Note that the calculation is based on the center coordinates of the region pixels.

The operator is applied when, for example, the location of a scenery of several regions (e.g., printed text on a rectangular paper or in rectangular print (justified lines)) must be found. The parameters of smallest_rectangle2SmallestRectangle2 are chosen in such a way that they can be used directly as input for the operators disp_rectangle2DispRectangle2 and gen_rectangle2GenRectangle2.

If more than one region is passed in Regionsregionsregions the results are stored in tuples, the index of a value in the tuple corresponding to the index of a region in the input. In case of empty region all parameters have the value 0.0 if no other behavior was set (see set_systemSetSystem).

Execution information🔗

Execution information

Multithreading type: reentrant (runs in parallel with non-exclusive operators).
Multithreading scope: global (may be called from any thread).
Automatically parallelized on tuple level.

Parameters🔗

Regionsregionsregions (input_object) region(-array) → objectHObjectHRegionHObjectHobject

Regions to be examined.

Rowrowrow (output_control) rectangle2.center.y(-array) → (real)HTuple (double)HTuple (double)Sequence[float]Htuple (double)

Line index of the center.

Columncolumncolumn (output_control) rectangle2.center.x(-array) → (real)HTuple (double)HTuple (double)Sequence[float]Htuple (double)

Column index of the center.

Phiphiphi (output_control) rectangle2.angle.rad(-array) → (real)HTuple (double)HTuple (double)Sequence[float]Htuple (double)

Orientation of the surrounding rectangle (arc measure)

Assertion: -pi / 2 < Phi && Phi <= pi / 2

Length1length1length_1 (output_control) rectangle2.hwidth(-array) → (real)HTuple (double)HTuple (double)Sequence[float]Htuple (double)

First radius (half length) of the surrounding rectangle.

Assertion: Length1 >= 0.0

Length2length2length_2 (output_control) rectangle2.hheight(-array) → (real)HTuple (double)HTuple (double)Sequence[float]Htuple (double)

Second radius (half width) of the surrounding rectangle.

Assertion: Length2 >= 0.0 && Length2 <= Length1

Example🔗

(HDevelop)

read_image(Image,'fabrik')
regiongrowing(Image,Regions,5,5,6,100)
smallest_rectangle2(Regions,Row,Column,Phi,Length1,Length2)
gen_rectangle2(Rectangle,Row,Column,Phi,Length1,Length2)
dev_set_draw ('margin')
dev_display(Rectangle)

(C++)

#include "HIOStream.h"
#if !defined(USE_IOSTREAM_H)
using namespace std\;
#endif
#include "HalconCpp.h"
using namespace Halcon\;

int main (int argc, char *argv[])
{
  Tuple    row, col, phi, len1, len2\;
 HImage   img (argv[1])\;
  HWindow  w\;
 img.Display (w)\;
 HRegionArray  reg  = img.Regiongrowing (5, 5, 6.0, 100)\;
  HRegionArray  seg  = reg.SelectShape ("area", "and", 100.0, 1000.0)\;
 row = seg.SmallestRectangle2 (&col, &phi, &len1, &len2)\;
 HRegionArray rect = HRegionArray::GenRectangle2 (row, col, phi, len1, len2)\;
 w.SetDraw   ("margin")\;
  w.SetColor  ("green")\;   reg.Display (w)\;
  w.SetColor  ("blue")\;    seg.Display (w)\;
  w.SetColor  ("red")\;     rect.Display (w)\;
  w.Click ()\;
 return(0)\;
}

Complexity🔗

If \(F\) is the area of the region and \(N\) is the number of supporting points of the convex hull, the runtime complexity is \(O(\sqrt{F} + N^2)\).

Result🔗

The operator smallest_rectangle2SmallestRectangle2 returns the value 2 (H_MSG_TRUE) if the input is not empty. The behavior in case of empty input (no input regions available) is set via the operator set_system('no_object_result',<Result>). The behavior in case of empty region (the region is the empty set) is set via set_system('empty_region_result',<Result>). If necessary an exception is raised.

Combinations with other operators🔗

Combinations

Possible predecessors

thresholdThreshold, regiongrowingRegiongrowing, connectionConnection, runlength_featuresRunlengthFeatures

Possible successors

disp_rectangle2DispRectangle2, gen_rectangle2GenRectangle2

Alternatives

elliptic_axisEllipticAxis, smallest_rectangle1SmallestRectangle1

Module🔗

Foundation