mirror of
https://github.com/opencv/opencv.git
synced 2026-07-31 08:13:04 +04:00
Merge pull request #11390 from dkurt:east_text_detection
This commit is contained in:
Alexander Alekhin
@@ -826,6 +826,10 @@ CV__DNN_EXPERIMENTAL_NS_BEGIN
|
||||
CV_OUT std::vector<int>& indices,
|
||||
const float eta = 1.f, const int top_k = 0);
|
||||
|
||||
CV_EXPORTS void NMSBoxes(const std::vector<RotatedRect>& bboxes, const std::vector<float>& scores,
|
||||
const float score_threshold, const float nms_threshold,
|
||||
CV_OUT std::vector<int>& indices,
|
||||
const float eta = 1.f, const int top_k = 0);
|
||||
|
||||
//! @}
|
||||
CV__DNN_EXPERIMENTAL_NS_END
|
||||
|
||||
@@ -8,6 +8,8 @@
|
||||
#include "precomp.hpp"
|
||||
#include "nms.inl.hpp"
|
||||
|
||||
#include <opencv2/imgproc.hpp>
|
||||
|
||||
namespace cv
|
||||
{
|
||||
namespace dnn
|
||||
@@ -28,6 +30,27 @@ void NMSBoxes(const std::vector<Rect>& bboxes, const std::vector<float>& scores,
|
||||
NMSFast_(bboxes, scores, score_threshold, nms_threshold, eta, top_k, indices, rectOverlap);
|
||||
}
|
||||
|
||||
static inline float rotatedRectIOU(const RotatedRect& a, const RotatedRect& b)
|
||||
{
|
||||
std::vector<Point2f> inter;
|
||||
int res = rotatedRectangleIntersection(a, b, inter);
|
||||
if (inter.empty() || res == INTERSECT_NONE)
|
||||
return 0.0f;
|
||||
if (res == INTERSECT_FULL)
|
||||
return 1.0f;
|
||||
float interArea = contourArea(inter);
|
||||
return interArea / (a.size.area() + b.size.area() - interArea);
|
||||
}
|
||||
|
||||
void NMSBoxes(const std::vector<RotatedRect>& bboxes, const std::vector<float>& scores,
|
||||
const float score_threshold, const float nms_threshold,
|
||||
std::vector<int>& indices, const float eta, const int top_k)
|
||||
{
|
||||
CV_Assert(bboxes.size() == scores.size(), score_threshold >= 0,
|
||||
nms_threshold >= 0, eta > 0);
|
||||
NMSFast_(bboxes, scores, score_threshold, nms_threshold, eta, top_k, indices, rotatedRectIOU);
|
||||
}
|
||||
|
||||
CV__DNN_EXPERIMENTAL_NS_END
|
||||
}// dnn
|
||||
}// cv
|
||||
|
||||
@@ -538,6 +538,37 @@ public:
|
||||
}
|
||||
};
|
||||
|
||||
// In case of resizing by factor.
|
||||
class ResizeBilinearSubgraph : public Subgraph
|
||||
{
|
||||
public:
|
||||
ResizeBilinearSubgraph()
|
||||
{
|
||||
int input = addNodeToMatch("");
|
||||
|
||||
int shape = addNodeToMatch("Shape", input);
|
||||
int stack = addNodeToMatch("Const");
|
||||
int stack_1 = addNodeToMatch("Const");
|
||||
int stack_2 = addNodeToMatch("Const");
|
||||
int strided_slice = addNodeToMatch("StridedSlice", shape, stack, stack_1, stack_2);
|
||||
int factorY = addNodeToMatch("Const");
|
||||
int mul = addNodeToMatch("Mul", strided_slice, factorY);
|
||||
|
||||
shape = addNodeToMatch("Shape", input);
|
||||
stack = addNodeToMatch("Const");
|
||||
stack_1 = addNodeToMatch("Const");
|
||||
stack_2 = addNodeToMatch("Const");
|
||||
strided_slice = addNodeToMatch("StridedSlice", shape, stack, stack_1, stack_2);
|
||||
int factorX = addNodeToMatch("Const");
|
||||
int mul_1 = addNodeToMatch("Mul", strided_slice, factorX);
|
||||
|
||||
int pack = addNodeToMatch("Pack", mul, mul_1);
|
||||
|
||||
addNodeToMatch("ResizeBilinear", input, pack);
|
||||
setFusedNode("ResizeBilinear", input, factorY, factorX);
|
||||
}
|
||||
};
|
||||
|
||||
void simplifySubgraphs(tensorflow::GraphDef& net)
|
||||
{
|
||||
std::vector<Ptr<Subgraph> > subgraphs;
|
||||
@@ -551,6 +582,7 @@ void simplifySubgraphs(tensorflow::GraphDef& net)
|
||||
subgraphs.push_back(Ptr<Subgraph>(new L2NormalizeSubgraph()));
|
||||
subgraphs.push_back(Ptr<Subgraph>(new DeconvolutionValidKerasSubgraph()));
|
||||
subgraphs.push_back(Ptr<Subgraph>(new DeconvolutionSameKerasSubgraph()));
|
||||
subgraphs.push_back(Ptr<Subgraph>(new ResizeBilinearSubgraph()));
|
||||
|
||||
int numNodes = net.node_size();
|
||||
std::vector<int> matchedNodesIds;
|
||||
|
||||
@@ -767,6 +767,26 @@ void TFImporter::populateNet(Net dstNet)
|
||||
}
|
||||
}
|
||||
}
|
||||
else if (type == "Sub")
|
||||
{
|
||||
bool haveConst = false;
|
||||
for(int ii = 0; !haveConst && ii < layer.input_size(); ++ii)
|
||||
{
|
||||
Pin input = parsePin(layer.input(ii));
|
||||
haveConst = value_id.find(input.name) != value_id.end();
|
||||
}
|
||||
CV_Assert(haveConst);
|
||||
|
||||
layerParams.blobs.resize(1);
|
||||
blobFromTensor(getConstBlob(layer, value_id), layerParams.blobs[0]);
|
||||
layerParams.blobs[0] *= -1;
|
||||
|
||||
int id = dstNet.addLayer(name, "Shift", layerParams);
|
||||
layer_id[name] = id;
|
||||
|
||||
// one input only
|
||||
connect(layer_id, dstNet, parsePin(layer.input(0)), id, 0);
|
||||
}
|
||||
else if (type == "MatMul")
|
||||
{
|
||||
CV_Assert(layer.input_size() == 2);
|
||||
|
||||
@@ -379,9 +379,24 @@ public:
|
||||
ResizeBilinearLayer(const LayerParams ¶ms) : Layer(params)
|
||||
{
|
||||
CV_Assert(!params.get<bool>("align_corners", false));
|
||||
CV_Assert(blobs.size() == 1, blobs[0].type() == CV_32SC1);
|
||||
outHeight = blobs[0].at<int>(0, 0);
|
||||
outWidth = blobs[0].at<int>(0, 1);
|
||||
CV_Assert(!blobs.empty());
|
||||
|
||||
for (size_t i = 0; i < blobs.size(); ++i)
|
||||
CV_Assert(blobs[i].type() == CV_32SC1);
|
||||
|
||||
if (blobs.size() == 1)
|
||||
{
|
||||
CV_Assert(blobs[0].total() == 2);
|
||||
outHeight = blobs[0].at<int>(0, 0);
|
||||
outWidth = blobs[0].at<int>(0, 1);
|
||||
}
|
||||
else
|
||||
{
|
||||
CV_Assert(blobs.size() == 2, blobs[0].total() == 1, blobs[1].total() == 1);
|
||||
factorHeight = blobs[0].at<int>(0, 0);
|
||||
factorWidth = blobs[1].at<int>(0, 0);
|
||||
outHeight = outWidth = 0;
|
||||
}
|
||||
}
|
||||
|
||||
static Ptr<Layer> create(LayerParams& params)
|
||||
@@ -397,12 +412,21 @@ public:
|
||||
std::vector<int> outShape(4);
|
||||
outShape[0] = inputs[0][0]; // batch size
|
||||
outShape[1] = inputs[0][1]; // number of channels
|
||||
outShape[2] = outHeight;
|
||||
outShape[3] = outWidth;
|
||||
outShape[2] = outHeight != 0 ? outHeight : (inputs[0][2] * factorHeight);
|
||||
outShape[3] = outWidth != 0 ? outWidth : (inputs[0][3] * factorWidth);
|
||||
outputs.assign(1, outShape);
|
||||
return false;
|
||||
}
|
||||
|
||||
virtual void finalize(const std::vector<Mat*>& inputs, std::vector<Mat> &outputs) CV_OVERRIDE
|
||||
{
|
||||
if (!outWidth && !outHeight)
|
||||
{
|
||||
outHeight = outputs[0].size[2];
|
||||
outWidth = outputs[0].size[3];
|
||||
}
|
||||
}
|
||||
|
||||
// This implementation is based on a reference implementation from
|
||||
// https://github.com/tensorflow/tensorflow/blob/master/tensorflow/contrib/lite/kernels/internal/reference/reference_ops.h
|
||||
virtual void forward(std::vector<Mat*> &inputs, std::vector<Mat> &outputs, std::vector<Mat> &internals) CV_OVERRIDE
|
||||
@@ -453,13 +477,51 @@ private:
|
||||
return x + size[3] * (y + size[2] * (c + size[1] * b));
|
||||
}
|
||||
|
||||
int outWidth, outHeight;
|
||||
int outWidth, outHeight, factorWidth, factorHeight;
|
||||
};
|
||||
|
||||
TEST(Test_TensorFlow, resize_bilinear)
|
||||
{
|
||||
CV_DNN_REGISTER_LAYER_CLASS(ResizeBilinear, ResizeBilinearLayer);
|
||||
runTensorFlowNet("resize_bilinear");
|
||||
runTensorFlowNet("resize_bilinear_factor");
|
||||
LayerFactory::unregisterLayer("ResizeBilinear");
|
||||
}
|
||||
|
||||
// inp = cv.imread('opencv_extra/testdata/cv/ximgproc/sources/08.png')
|
||||
// inp = inp[:,:,[2, 1, 0]].astype(np.float32).reshape(1, 512, 512, 3)
|
||||
// outs = sess.run([sess.graph.get_tensor_by_name('feature_fusion/Conv_7/Sigmoid:0'),
|
||||
// sess.graph.get_tensor_by_name('feature_fusion/concat_3:0')],
|
||||
// feed_dict={'input_images:0': inp})
|
||||
// scores = np.ascontiguousarray(outs[0].transpose(0, 3, 1, 2))
|
||||
// geometry = np.ascontiguousarray(outs[1].transpose(0, 3, 1, 2))
|
||||
// np.save('east_text_detection.scores.npy', scores)
|
||||
// np.save('east_text_detection.geometry.npy', geometry)
|
||||
TEST(Test_TensorFlow, EAST_text_detection)
|
||||
{
|
||||
CV_DNN_REGISTER_LAYER_CLASS(ResizeBilinear, ResizeBilinearLayer);
|
||||
std::string netPath = findDataFile("dnn/frozen_east_text_detection.pb", false);
|
||||
std::string imgPath = findDataFile("cv/ximgproc/sources/08.png", false);
|
||||
std::string refScoresPath = findDataFile("dnn/east_text_detection.scores.npy", false);
|
||||
std::string refGeometryPath = findDataFile("dnn/east_text_detection.geometry.npy", false);
|
||||
|
||||
Net net = readNet(findDataFile("dnn/frozen_east_text_detection.pb", false));
|
||||
|
||||
Mat img = imread(imgPath);
|
||||
Mat inp = blobFromImage(img, 1.0, Size(), Scalar(123.68, 116.78, 103.94), true, false);
|
||||
net.setInput(inp);
|
||||
|
||||
std::vector<Mat> outs;
|
||||
std::vector<String> outNames(2);
|
||||
outNames[0] = "feature_fusion/Conv_7/Sigmoid";
|
||||
outNames[1] = "feature_fusion/concat_3";
|
||||
net.forward(outs, outNames);
|
||||
|
||||
Mat scores = outs[0];
|
||||
Mat geometry = outs[1];
|
||||
|
||||
normAssert(scores, blobFromNPY(refScoresPath), "scores");
|
||||
normAssert(geometry, blobFromNPY(refGeometryPath), "geometry", 5e-5, 1e-3);
|
||||
LayerFactory::unregisterLayer("ResizeBilinear");
|
||||
}
|
||||
|
||||
|
||||
@@ -219,13 +219,15 @@ int rotatedRectangleIntersection( const RotatedRect& rect1, const RotatedRect& r
|
||||
}
|
||||
}
|
||||
|
||||
// Get rid of dupes
|
||||
// Get rid of dupes and order points.
|
||||
for( int i = 0; i < (int)intersection.size()-1; i++ )
|
||||
{
|
||||
float dx1 = intersection[i + 1].x - intersection[i].x;
|
||||
float dy1 = intersection[i + 1].y - intersection[i].y;
|
||||
for( size_t j = i+1; j < intersection.size(); j++ )
|
||||
{
|
||||
float dx = intersection[i].x - intersection[j].x;
|
||||
float dy = intersection[i].y - intersection[j].y;
|
||||
float dx = intersection[j].x - intersection[i].x;
|
||||
float dy = intersection[j].y - intersection[i].y;
|
||||
double d2 = dx*dx + dy*dy; // can be a really small number, need double here
|
||||
|
||||
if( d2 < samePointEps*samePointEps )
|
||||
@@ -235,6 +237,12 @@ int rotatedRectangleIntersection( const RotatedRect& rect1, const RotatedRect& r
|
||||
intersection.pop_back();
|
||||
j--; // restart check
|
||||
}
|
||||
else if (dx1 * dy - dy1 * dx < 0)
|
||||
{
|
||||
std::swap(intersection[i + 1], intersection[j]);
|
||||
dx1 = dx;
|
||||
dy1 = dy;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -66,8 +66,27 @@ private:
|
||||
void test7();
|
||||
void test8();
|
||||
void test9();
|
||||
void test10();
|
||||
void test11();
|
||||
void test12();
|
||||
void test13();
|
||||
void test14();
|
||||
};
|
||||
|
||||
static void compare(const std::vector<Point2f>& test, const std::vector<Point2f>& target)
|
||||
{
|
||||
ASSERT_EQ(test.size(), target.size());
|
||||
ASSERT_TRUE(test.size() < 4 || isContourConvex(test));
|
||||
ASSERT_TRUE(target.size() < 4 || isContourConvex(target));
|
||||
for( size_t i = 0; i < test.size(); i++ )
|
||||
{
|
||||
double dx = test[i].x - target[i].x;
|
||||
double dy = test[i].y - target[i].y;
|
||||
double r = sqrt(dx*dx + dy*dy);
|
||||
ASSERT_LT(r, ACCURACY);
|
||||
}
|
||||
}
|
||||
|
||||
void CV_RotatedRectangleIntersectionTest::run(int)
|
||||
{
|
||||
// See pics/intersection.png for the scenarios we are testing
|
||||
@@ -92,28 +111,20 @@ void CV_RotatedRectangleIntersectionTest::run(int)
|
||||
test7();
|
||||
test8();
|
||||
test9();
|
||||
test10();
|
||||
test11();
|
||||
test12();
|
||||
test13();
|
||||
test14();
|
||||
}
|
||||
|
||||
void CV_RotatedRectangleIntersectionTest::test1()
|
||||
{
|
||||
// no intersection
|
||||
|
||||
RotatedRect rect1, rect2;
|
||||
|
||||
rect1.center.x = 0;
|
||||
rect1.center.y = 0;
|
||||
rect1.size.width = 2;
|
||||
rect1.size.height = 2;
|
||||
rect1.angle = 12.0f;
|
||||
|
||||
rect2.center.x = 10;
|
||||
rect2.center.y = 10;
|
||||
rect2.size.width = 2;
|
||||
rect2.size.height = 2;
|
||||
rect2.angle = 34.0f;
|
||||
RotatedRect rect1(Point2f(0, 0), Size2f(2, 2), 12.0f);
|
||||
RotatedRect rect2(Point2f(10, 10), Size2f(2, 2), 34.0f);
|
||||
|
||||
vector<Point2f> vertices;
|
||||
|
||||
int ret = rotatedRectangleIntersection(rect1, rect2, vertices);
|
||||
|
||||
CV_Assert(ret == INTERSECT_NONE);
|
||||
@@ -123,375 +134,243 @@ void CV_RotatedRectangleIntersectionTest::test1()
|
||||
void CV_RotatedRectangleIntersectionTest::test2()
|
||||
{
|
||||
// partial intersection, rectangles translated
|
||||
|
||||
RotatedRect rect1, rect2;
|
||||
|
||||
rect1.center.x = 0;
|
||||
rect1.center.y = 0;
|
||||
rect1.size.width = 2;
|
||||
rect1.size.height = 2;
|
||||
rect1.angle = 0;
|
||||
|
||||
rect2.center.x = 1;
|
||||
rect2.center.y = 1;
|
||||
rect2.size.width = 2;
|
||||
rect2.size.height = 2;
|
||||
rect2.angle = 0;
|
||||
RotatedRect rect1(Point2f(0, 0), Size2f(2, 2), 0.0f);
|
||||
RotatedRect rect2(Point2f(1, 1), Size2f(2, 2), 0.0f);
|
||||
|
||||
vector<Point2f> vertices;
|
||||
|
||||
int ret = rotatedRectangleIntersection(rect1, rect2, vertices);
|
||||
|
||||
CV_Assert(ret == INTERSECT_PARTIAL);
|
||||
CV_Assert(vertices.size() == 4);
|
||||
|
||||
vector<Point2f> possibleVertices(4);
|
||||
|
||||
possibleVertices[0] = Point2f(0.0f, 0.0f);
|
||||
possibleVertices[1] = Point2f(1.0f, 1.0f);
|
||||
possibleVertices[2] = Point2f(0.0f, 1.0f);
|
||||
possibleVertices[3] = Point2f(1.0f, 0.0f);
|
||||
|
||||
for( size_t i = 0; i < vertices.size(); i++ )
|
||||
{
|
||||
double bestR = DBL_MAX;
|
||||
|
||||
for( size_t j = 0; j < possibleVertices.size(); j++ )
|
||||
{
|
||||
double dx = vertices[i].x - possibleVertices[j].x;
|
||||
double dy = vertices[i].y - possibleVertices[j].y;
|
||||
double r = sqrt(dx*dx + dy*dy);
|
||||
|
||||
bestR = std::min(bestR, r);
|
||||
}
|
||||
|
||||
CV_Assert(bestR < ACCURACY);
|
||||
}
|
||||
vector<Point2f> targetVertices(4);
|
||||
targetVertices[0] = Point2f(1.0f, 0.0f);
|
||||
targetVertices[1] = Point2f(1.0f, 1.0f);
|
||||
targetVertices[2] = Point2f(0.0f, 1.0f);
|
||||
targetVertices[3] = Point2f(0.0f, 0.0f);
|
||||
compare(vertices, targetVertices);
|
||||
}
|
||||
|
||||
void CV_RotatedRectangleIntersectionTest::test3()
|
||||
{
|
||||
// partial intersection, rectangles rotated 45 degree on the corner, forms a triangle intersection
|
||||
RotatedRect rect1, rect2;
|
||||
|
||||
rect1.center.x = 0;
|
||||
rect1.center.y = 0;
|
||||
rect1.size.width = 2;
|
||||
rect1.size.height = 2;
|
||||
rect1.angle = 0;
|
||||
|
||||
rect2.center.x = 1;
|
||||
rect2.center.y = 1;
|
||||
rect2.size.width = sqrt(2.0f);
|
||||
rect2.size.height = 20;
|
||||
rect2.angle = 45.0f;
|
||||
RotatedRect rect1(Point2f(0, 0), Size2f(2, 2), 0.0f);
|
||||
RotatedRect rect2(Point2f(1, 1), Size2f(sqrt(2.0f), 20), 45.0f);
|
||||
|
||||
vector<Point2f> vertices;
|
||||
|
||||
int ret = rotatedRectangleIntersection(rect1, rect2, vertices);
|
||||
|
||||
CV_Assert(ret == INTERSECT_PARTIAL);
|
||||
CV_Assert(vertices.size() == 3);
|
||||
|
||||
vector<Point2f> possibleVertices(3);
|
||||
|
||||
possibleVertices[0] = Point2f(1.0f, 1.0f);
|
||||
possibleVertices[1] = Point2f(0.0f, 1.0f);
|
||||
possibleVertices[2] = Point2f(1.0f, 0.0f);
|
||||
|
||||
for( size_t i = 0; i < vertices.size(); i++ )
|
||||
{
|
||||
double bestR = DBL_MAX;
|
||||
|
||||
for( size_t j = 0; j < possibleVertices.size(); j++ )
|
||||
{
|
||||
double dx = vertices[i].x - possibleVertices[j].x;
|
||||
double dy = vertices[i].y - possibleVertices[j].y;
|
||||
double r = sqrt(dx*dx + dy*dy);
|
||||
|
||||
bestR = std::min(bestR, r);
|
||||
}
|
||||
|
||||
CV_Assert(bestR < ACCURACY);
|
||||
}
|
||||
vector<Point2f> targetVertices(3);
|
||||
targetVertices[0] = Point2f(1.0f, 0.0f);
|
||||
targetVertices[1] = Point2f(1.0f, 1.0f);
|
||||
targetVertices[2] = Point2f(0.0f, 1.0f);
|
||||
compare(vertices, targetVertices);
|
||||
}
|
||||
|
||||
void CV_RotatedRectangleIntersectionTest::test4()
|
||||
{
|
||||
// full intersection, rectangles of same size directly on top of each other
|
||||
|
||||
RotatedRect rect1, rect2;
|
||||
|
||||
rect1.center.x = 0;
|
||||
rect1.center.y = 0;
|
||||
rect1.size.width = 2;
|
||||
rect1.size.height = 2;
|
||||
rect1.angle = 0;
|
||||
|
||||
rect2.center.x = 0;
|
||||
rect2.center.y = 0;
|
||||
rect2.size.width = 2;
|
||||
rect2.size.height = 2;
|
||||
rect2.angle = 0;
|
||||
RotatedRect rect1(Point2f(0, 0), Size2f(2, 2), 0.0f);
|
||||
RotatedRect rect2(Point2f(0, 0), Size2f(2, 2), 0.0f);
|
||||
|
||||
vector<Point2f> vertices;
|
||||
|
||||
int ret = rotatedRectangleIntersection(rect1, rect2, vertices);
|
||||
|
||||
CV_Assert(ret == INTERSECT_FULL);
|
||||
CV_Assert(vertices.size() == 4);
|
||||
|
||||
vector<Point2f> possibleVertices(4);
|
||||
|
||||
possibleVertices[0] = Point2f(-1.0f, 1.0f);
|
||||
possibleVertices[1] = Point2f(1.0f, -1.0f);
|
||||
possibleVertices[2] = Point2f(-1.0f, -1.0f);
|
||||
possibleVertices[3] = Point2f(1.0f, 1.0f);
|
||||
|
||||
for( size_t i = 0; i < vertices.size(); i++ )
|
||||
{
|
||||
double bestR = DBL_MAX;
|
||||
|
||||
for( size_t j = 0; j < possibleVertices.size(); j++ )
|
||||
{
|
||||
double dx = vertices[i].x - possibleVertices[j].x;
|
||||
double dy = vertices[i].y - possibleVertices[j].y;
|
||||
double r = sqrt(dx*dx + dy*dy);
|
||||
|
||||
bestR = std::min(bestR, r);
|
||||
}
|
||||
|
||||
CV_Assert(bestR < ACCURACY);
|
||||
}
|
||||
vector<Point2f> targetVertices(4);
|
||||
targetVertices[0] = Point2f(-1.0f, 1.0f);
|
||||
targetVertices[1] = Point2f(-1.0f, -1.0f);
|
||||
targetVertices[2] = Point2f(1.0f, -1.0f);
|
||||
targetVertices[3] = Point2f(1.0f, 1.0f);
|
||||
compare(vertices, targetVertices);
|
||||
}
|
||||
|
||||
void CV_RotatedRectangleIntersectionTest::test5()
|
||||
{
|
||||
// partial intersection, rectangle on top rotated 45 degrees
|
||||
|
||||
RotatedRect rect1, rect2;
|
||||
|
||||
rect1.center.x = 0;
|
||||
rect1.center.y = 0;
|
||||
rect1.size.width = 2;
|
||||
rect1.size.height = 2;
|
||||
rect1.angle = 0;
|
||||
|
||||
rect2.center.x = 0;
|
||||
rect2.center.y = 0;
|
||||
rect2.size.width = 2;
|
||||
rect2.size.height = 2;
|
||||
rect2.angle = 45.0f;
|
||||
RotatedRect rect1(Point2f(0, 0), Size2f(2, 2), 0.0f);
|
||||
RotatedRect rect2(Point2f(0, 0), Size2f(2, 2), 45.0f);
|
||||
|
||||
vector<Point2f> vertices;
|
||||
|
||||
int ret = rotatedRectangleIntersection(rect1, rect2, vertices);
|
||||
|
||||
CV_Assert(ret == INTERSECT_PARTIAL);
|
||||
CV_Assert(vertices.size() == 8);
|
||||
|
||||
vector<Point2f> possibleVertices(8);
|
||||
|
||||
possibleVertices[0] = Point2f(-1.0f, -0.414214f);
|
||||
possibleVertices[1] = Point2f(-1.0f, 0.414214f);
|
||||
possibleVertices[2] = Point2f(-0.414214f, -1.0f);
|
||||
possibleVertices[3] = Point2f(0.414214f, -1.0f);
|
||||
possibleVertices[4] = Point2f(1.0f, -0.414214f);
|
||||
possibleVertices[5] = Point2f(1.0f, 0.414214f);
|
||||
possibleVertices[6] = Point2f(0.414214f, 1.0f);
|
||||
possibleVertices[7] = Point2f(-0.414214f, 1.0f);
|
||||
|
||||
for( size_t i = 0; i < vertices.size(); i++ )
|
||||
{
|
||||
double bestR = DBL_MAX;
|
||||
|
||||
for( size_t j = 0; j < possibleVertices.size(); j++ )
|
||||
{
|
||||
double dx = vertices[i].x - possibleVertices[j].x;
|
||||
double dy = vertices[i].y - possibleVertices[j].y;
|
||||
double r = sqrt(dx*dx + dy*dy);
|
||||
|
||||
bestR = std::min(bestR, r);
|
||||
}
|
||||
|
||||
CV_Assert(bestR < ACCURACY);
|
||||
}
|
||||
vector<Point2f> targetVertices(8);
|
||||
targetVertices[0] = Point2f(-1.0f, -0.414214f);
|
||||
targetVertices[1] = Point2f(-0.414214f, -1.0f);
|
||||
targetVertices[2] = Point2f(0.414214f, -1.0f);
|
||||
targetVertices[3] = Point2f(1.0f, -0.414214f);
|
||||
targetVertices[4] = Point2f(1.0f, 0.414214f);
|
||||
targetVertices[5] = Point2f(0.414214f, 1.0f);
|
||||
targetVertices[6] = Point2f(-0.414214f, 1.0f);
|
||||
targetVertices[7] = Point2f(-1.0f, 0.414214f);
|
||||
compare(vertices, targetVertices);
|
||||
}
|
||||
|
||||
void CV_RotatedRectangleIntersectionTest::test6()
|
||||
{
|
||||
// 6 - partial intersection, rectangle on top of different size
|
||||
|
||||
RotatedRect rect1, rect2;
|
||||
|
||||
rect1.center.x = 0;
|
||||
rect1.center.y = 0;
|
||||
rect1.size.width = 2;
|
||||
rect1.size.height = 2;
|
||||
rect1.angle = 0;
|
||||
|
||||
rect2.center.x = 0;
|
||||
rect2.center.y = 0;
|
||||
rect2.size.width = 2;
|
||||
rect2.size.height = 10;
|
||||
rect2.angle = 0;
|
||||
RotatedRect rect1(Point2f(0, 0), Size2f(2, 2), 0.0f);
|
||||
RotatedRect rect2(Point2f(0, 0), Size2f(2, 10), 0.0f);
|
||||
|
||||
vector<Point2f> vertices;
|
||||
|
||||
int ret = rotatedRectangleIntersection(rect1, rect2, vertices);
|
||||
|
||||
CV_Assert(ret == INTERSECT_PARTIAL);
|
||||
CV_Assert(vertices.size() == 4);
|
||||
|
||||
vector<Point2f> possibleVertices(4);
|
||||
|
||||
possibleVertices[0] = Point2f(1.0f, 1.0f);
|
||||
possibleVertices[1] = Point2f(1.0f, -1.0f);
|
||||
possibleVertices[2] = Point2f(-1.0f, -1.0f);
|
||||
possibleVertices[3] = Point2f(-1.0f, 1.0f);
|
||||
|
||||
for( size_t i = 0; i < vertices.size(); i++ )
|
||||
{
|
||||
double bestR = DBL_MAX;
|
||||
|
||||
for( size_t j = 0; j < possibleVertices.size(); j++ )
|
||||
{
|
||||
double dx = vertices[i].x - possibleVertices[j].x;
|
||||
double dy = vertices[i].y - possibleVertices[j].y;
|
||||
double r = sqrt(dx*dx + dy*dy);
|
||||
|
||||
bestR = std::min(bestR, r);
|
||||
}
|
||||
|
||||
CV_Assert(bestR < ACCURACY);
|
||||
}
|
||||
vector<Point2f> targetVertices(4);
|
||||
targetVertices[0] = Point2f(-1.0f, -1.0f);
|
||||
targetVertices[1] = Point2f(1.0f, -1.0f);
|
||||
targetVertices[2] = Point2f(1.0f, 1.0f);
|
||||
targetVertices[3] = Point2f(-1.0f, 1.0f);
|
||||
compare(vertices, targetVertices);
|
||||
}
|
||||
|
||||
void CV_RotatedRectangleIntersectionTest::test7()
|
||||
{
|
||||
// full intersection, rectangle fully enclosed in the other
|
||||
|
||||
RotatedRect rect1, rect2;
|
||||
|
||||
rect1.center.x = 0;
|
||||
rect1.center.y = 0;
|
||||
rect1.size.width = 12.34f;
|
||||
rect1.size.height = 56.78f;
|
||||
rect1.angle = 0;
|
||||
|
||||
rect2.center.x = 0;
|
||||
rect2.center.y = 0;
|
||||
rect2.size.width = 2;
|
||||
rect2.size.height = 2;
|
||||
rect2.angle = 0;
|
||||
RotatedRect rect1(Point2f(0, 0), Size2f(12.34f, 56.78f), 0.0f);
|
||||
RotatedRect rect2(Point2f(0, 0), Size2f(2, 2), 0.0f);
|
||||
|
||||
vector<Point2f> vertices;
|
||||
|
||||
int ret = rotatedRectangleIntersection(rect1, rect2, vertices);
|
||||
|
||||
CV_Assert(ret == INTERSECT_FULL);
|
||||
CV_Assert(vertices.size() == 4);
|
||||
|
||||
vector<Point2f> possibleVertices(4);
|
||||
|
||||
possibleVertices[0] = Point2f(1.0f, 1.0f);
|
||||
possibleVertices[1] = Point2f(1.0f, -1.0f);
|
||||
possibleVertices[2] = Point2f(-1.0f, -1.0f);
|
||||
possibleVertices[3] = Point2f(-1.0f, 1.0f);
|
||||
|
||||
for( size_t i = 0; i < vertices.size(); i++ )
|
||||
{
|
||||
double bestR = DBL_MAX;
|
||||
|
||||
for( size_t j = 0; j < possibleVertices.size(); j++ )
|
||||
{
|
||||
double dx = vertices[i].x - possibleVertices[j].x;
|
||||
double dy = vertices[i].y - possibleVertices[j].y;
|
||||
double r = sqrt(dx*dx + dy*dy);
|
||||
|
||||
bestR = std::min(bestR, r);
|
||||
}
|
||||
|
||||
CV_Assert(bestR < ACCURACY);
|
||||
}
|
||||
vector<Point2f> targetVertices(4);
|
||||
targetVertices[0] = Point2f(-1.0f, 1.0f);
|
||||
targetVertices[1] = Point2f(-1.0f, -1.0f);
|
||||
targetVertices[2] = Point2f(1.0f, -1.0f);
|
||||
targetVertices[3] = Point2f(1.0f, 1.0f);
|
||||
compare(vertices, targetVertices);
|
||||
}
|
||||
|
||||
void CV_RotatedRectangleIntersectionTest::test8()
|
||||
{
|
||||
// full intersection, rectangle fully enclosed in the other
|
||||
|
||||
RotatedRect rect1, rect2;
|
||||
|
||||
rect1.center.x = 0;
|
||||
rect1.center.y = 0;
|
||||
rect1.size.width = 2;
|
||||
rect1.size.height = 2;
|
||||
rect1.angle = 0;
|
||||
|
||||
rect2.center.x = 2;
|
||||
rect2.center.y = 2;
|
||||
rect2.size.width = 2;
|
||||
rect2.size.height = 2;
|
||||
rect2.angle = 0;
|
||||
// intersection by a single vertex
|
||||
RotatedRect rect1(Point2f(0, 0), Size2f(2, 2), 0.0f);
|
||||
RotatedRect rect2(Point2f(2, 2), Size2f(2, 2), 0.0f);
|
||||
|
||||
vector<Point2f> vertices;
|
||||
|
||||
int ret = rotatedRectangleIntersection(rect1, rect2, vertices);
|
||||
|
||||
CV_Assert(ret == INTERSECT_PARTIAL);
|
||||
CV_Assert(vertices.size() == 1);
|
||||
|
||||
double dx = vertices[0].x - 1;
|
||||
double dy = vertices[0].y - 1;
|
||||
double r = sqrt(dx*dx + dy*dy);
|
||||
|
||||
CV_Assert(r < ACCURACY);
|
||||
compare(vertices, vector<Point2f>(1, Point2f(1.0f, 1.0f)));
|
||||
}
|
||||
|
||||
void CV_RotatedRectangleIntersectionTest::test9()
|
||||
{
|
||||
// full intersection, rectangle fully enclosed in the other
|
||||
|
||||
RotatedRect rect1, rect2;
|
||||
|
||||
rect1.center.x = 0;
|
||||
rect1.center.y = 0;
|
||||
rect1.size.width = 2;
|
||||
rect1.size.height = 2;
|
||||
rect1.angle = 0;
|
||||
|
||||
rect2.center.x = 2;
|
||||
rect2.center.y = 0;
|
||||
rect2.size.width = 2;
|
||||
rect2.size.height = 123.45f;
|
||||
rect2.angle = 0;
|
||||
RotatedRect rect1(Point2f(0, 0), Size2f(2, 2), 0.0f);
|
||||
RotatedRect rect2(Point2f(2, 0), Size2f(2, 123.45f), 0.0f);
|
||||
|
||||
vector<Point2f> vertices;
|
||||
|
||||
int ret = rotatedRectangleIntersection(rect1, rect2, vertices);
|
||||
|
||||
CV_Assert(ret == INTERSECT_PARTIAL);
|
||||
CV_Assert(vertices.size() == 2);
|
||||
|
||||
vector<Point2f> possibleVertices(2);
|
||||
vector<Point2f> targetVertices(2);
|
||||
targetVertices[0] = Point2f(1.0f, -1.0f);
|
||||
targetVertices[1] = Point2f(1.0f, 1.0f);
|
||||
compare(vertices, targetVertices);
|
||||
}
|
||||
|
||||
possibleVertices[0] = Point2f(1.0f, 1.0f);
|
||||
possibleVertices[1] = Point2f(1.0f, -1.0f);
|
||||
void CV_RotatedRectangleIntersectionTest::test10()
|
||||
{
|
||||
// three points of rect2 are inside rect1.
|
||||
RotatedRect rect1(Point2f(0, 0), Size2f(2, 2), 0.0f);
|
||||
RotatedRect rect2(Point2f(0, 0.5), Size2f(1, 1), 45.0f);
|
||||
|
||||
for( size_t i = 0; i < vertices.size(); i++ )
|
||||
vector<Point2f> vertices;
|
||||
int ret = rotatedRectangleIntersection(rect1, rect2, vertices);
|
||||
|
||||
CV_Assert(ret == INTERSECT_PARTIAL);
|
||||
|
||||
vector<Point2f> targetVertices(5);
|
||||
targetVertices[0] = Point2f(0.207107f, 1.0f);
|
||||
targetVertices[1] = Point2f(-0.207107f, 1.0f);
|
||||
targetVertices[2] = Point2f(-0.707107f, 0.5f);
|
||||
targetVertices[3] = Point2f(0.0f, -0.207107f);
|
||||
targetVertices[4] = Point2f(0.707107f, 0.5f);
|
||||
compare(vertices, targetVertices);
|
||||
}
|
||||
|
||||
void CV_RotatedRectangleIntersectionTest::test11()
|
||||
{
|
||||
RotatedRect rect1(Point2f(0, 0), Size2f(4, 2), 0.0f);
|
||||
RotatedRect rect2(Point2f(0, 0), Size2f(2, 2), -45.0f);
|
||||
|
||||
vector<Point2f> vertices;
|
||||
int ret = rotatedRectangleIntersection(rect1, rect2, vertices);
|
||||
|
||||
CV_Assert(ret == INTERSECT_PARTIAL);
|
||||
|
||||
vector<Point2f> targetVertices(6);
|
||||
targetVertices[0] = Point2f(-0.414214f, -1.0f);
|
||||
targetVertices[1] = Point2f(0.414213f, -1.0f);
|
||||
targetVertices[2] = Point2f(1.41421f, 0.0f);
|
||||
targetVertices[3] = Point2f(0.414214f, 1.0f);
|
||||
targetVertices[4] = Point2f(-0.414213f, 1.0f);
|
||||
targetVertices[5] = Point2f(-1.41421f, 0.0f);
|
||||
compare(vertices, targetVertices);
|
||||
}
|
||||
|
||||
void CV_RotatedRectangleIntersectionTest::test12()
|
||||
{
|
||||
RotatedRect rect1(Point2f(0, 0), Size2f(2, 2), 0.0f);
|
||||
RotatedRect rect2(Point2f(0, 1), Size2f(1, 1), 0.0f);
|
||||
|
||||
vector<Point2f> vertices;
|
||||
int ret = rotatedRectangleIntersection(rect1, rect2, vertices);
|
||||
|
||||
CV_Assert(ret == INTERSECT_PARTIAL);
|
||||
|
||||
vector<Point2f> targetVertices(4);
|
||||
targetVertices[0] = Point2f(-0.5f, 1.0f);
|
||||
targetVertices[1] = Point2f(-0.5f, 0.5f);
|
||||
targetVertices[2] = Point2f(0.5f, 0.5f);
|
||||
targetVertices[3] = Point2f(0.5f, 1.0f);
|
||||
compare(vertices, targetVertices);
|
||||
}
|
||||
|
||||
void CV_RotatedRectangleIntersectionTest::test13()
|
||||
{
|
||||
RotatedRect rect1(Point2f(0, 0), Size2f(1, 3), 0.0f);
|
||||
RotatedRect rect2(Point2f(0, 1), Size2f(3, 1), 0.0f);
|
||||
|
||||
vector<Point2f> vertices;
|
||||
int ret = rotatedRectangleIntersection(rect1, rect2, vertices);
|
||||
|
||||
CV_Assert(ret == INTERSECT_PARTIAL);
|
||||
|
||||
vector<Point2f> targetVertices(4);
|
||||
targetVertices[0] = Point2f(-0.5f, 0.5f);
|
||||
targetVertices[1] = Point2f(0.5f, 0.5f);
|
||||
targetVertices[2] = Point2f(0.5f, 1.5f);
|
||||
targetVertices[3] = Point2f(-0.5f, 1.5f);
|
||||
compare(vertices, targetVertices);
|
||||
}
|
||||
|
||||
void CV_RotatedRectangleIntersectionTest::test14()
|
||||
{
|
||||
const int kNumTests = 100;
|
||||
const int kWidth = 5;
|
||||
const int kHeight = 5;
|
||||
RotatedRect rects[2];
|
||||
std::vector<Point2f> inter;
|
||||
for (int i = 0; i < kNumTests; ++i)
|
||||
{
|
||||
double bestR = DBL_MAX;
|
||||
|
||||
for( size_t j = 0; j < possibleVertices.size(); j++ )
|
||||
for (int j = 0; j < 2; ++j)
|
||||
{
|
||||
double dx = vertices[i].x - possibleVertices[j].x;
|
||||
double dy = vertices[i].y - possibleVertices[j].y;
|
||||
double r = sqrt(dx*dx + dy*dy);
|
||||
|
||||
bestR = std::min(bestR, r);
|
||||
rects[j].center = Point2f((float)(rand() % kWidth), (float)(rand() % kHeight));
|
||||
rects[j].size = Size2f(rand() % kWidth + 1.0f, rand() % kHeight + 1.0f);
|
||||
rects[j].angle = (float)(rand() % 360);
|
||||
}
|
||||
|
||||
CV_Assert(bestR < ACCURACY);
|
||||
rotatedRectangleIntersection(rects[0], rects[1], inter);
|
||||
ASSERT_TRUE(inter.size() < 4 || isContourConvex(inter));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user