计算透视变换目标图像的纵横比
Calculating aspect ratio of Perspective Transform destination image
我最近在 Android[= 的应用程序 OpenCV 中实现了 Perspective Transform 40=]。几乎所有的事情都没有问题，但有一方面需要做更多的工作。
问题是我不知道如何计算Perspective Transform目标图像的正确宽高比（不必手动设置），以便它可以计算图像的宽高比真实尺寸 thing/image 尽管相机的角度 。注意起始坐标不是梯形，是四边形
如果我有一张从大约 45 度角拍摄的书的照片，并且我希望目标图像的纵横比与这本书的纵横比几乎相同。 2D 照片很难做到，但 CamScanner 应用程序可以完美地做到这一点。我用非常简单的方法来计算目标图像的大小（没有期望它能按我的意愿工作），但它使 45 度角的图像缩短了约 20%，并且当降低角度时图像高度降低重要的是，尽管 CamScanner 完美地完成了角度：
这里，CamScanner 将目标图像（第二张）的纵横比保持为与书本相同的纵横比，即使在约 20 度角时也能相当准确。
同时，我的代码看起来像这样（在计算目标图像的大小时我无意让它像我在这个问题中问的那样工作）：
public static Mat PerspectiveTransform(Point[] cropCoordinates, float ratioW, float ratioH, Bitmap croppedImage)
{
if (cropCoordinates.length != 4) return null;
double width1, width2, height1, height2, avgw, avgh;
Mat src = new Mat();
List<Point> startCoords = new ArrayList<>();
List<Point> resultCoords = new ArrayList<>();
Utils.bitmapToMat(croppedImage, src);
for (int i = 0; i < 4; i++)
{
if (cropCoordinates[i].y < 0 ) new Point(cropCoordinates[i].x, 0);
startCoords.add(new Point(cropCoordinates[i].x * ratioW, cropCoordinates[i].y * ratioH));
}
width1 = Math.sqrt(Math.pow(startCoords.get(2).x - startCoords.get(3).x,2) + Math.pow(startCoords.get(2).y - startCoords.get(3).y,2));
width2 = Math.sqrt(Math.pow(startCoords.get(1).x - startCoords.get(0).x,2) + Math.pow(startCoords.get(1).y - startCoords.get(0).y,2));
height1 = Math.sqrt(Math.pow(startCoords.get(1).x - startCoords.get(2).x, 2) + Math.pow(startCoords.get(1).y - startCoords.get(2).y, 2));
height2 = Math.sqrt(Math.pow(startCoords.get(0).x - startCoords.get(3).x, 2) + Math.pow(startCoords.get(0).y - startCoords.get(3).y, 2));
avgw = (width1 + width2) / 2;
avgh = (height1 + height2) / 2;
resultCoords.add(new Point(0, 0));
resultCoords.add(new Point(avgw-1, 0));
resultCoords.add(new Point(avgw-1, avgh-1));
resultCoords.add(new Point(0, avgh-1));
Mat start = Converters.vector_Point2f_to_Mat(startCoords);
Mat result = Converters.vector_Point2d_to_Mat(resultCoords);
start.convertTo(start, CvType.CV_32FC2);
result.convertTo(result,CvType.CV_32FC2);
Mat mat = new Mat();
Mat perspective = Imgproc.getPerspectiveTransform(start, result);
Imgproc.warpPerspective(src, mat, perspective, new Size(avgw, avgh));
return mat;
}
从相对相同的角度来看，我的方法产生了这个结果：
我想知道这是怎么做到的？我很感兴趣他们是如何通过坐标为 4 来计算物体的长度的角落。另外，如果可能的话，请提供一些代码/数学解释或similar/same东西的文章。
提前谢谢你。
这个问题之前在 SO 上出现过几次，但我从来没有看到完整的答案，所以就这样吧。此处显示的实现基于本文，该论文导出了完整的方程式：http://research.microsoft.com/en-us/um/people/zhang/papers/tr03-39.pdf
本质上，它表明假设一个针孔相机模型，可以计算投影矩形的纵横比（但不是比例，这不足为奇）。本质上，可以解决焦距，然后得到纵横比。这是 python 中使用 OpenCV 的示例实现。请注意，您需要以正确的顺序检测到 4 个角，否则它将不起作用（注意顺序，它是一个锯齿形）。报告的错误率在 3-5% 的范围内。
import math
import cv2
import scipy.spatial.distance
import numpy as np
img = cv2.imread('img.png')
(rows,cols,_) = img.shape
#image center
u0 = (cols)/2.0
v0 = (rows)/2.0
#detected corners on the original image
p = []
p.append((67,74))
p.append((270,64))
p.append((10,344))
p.append((343,331))
#widths and heights of the projected image
w1 = scipy.spatial.distance.euclidean(p[0],p[1])
w2 = scipy.spatial.distance.euclidean(p[2],p[3])
h1 = scipy.spatial.distance.euclidean(p[0],p[2])
h2 = scipy.spatial.distance.euclidean(p[1],p[3])
w = max(w1,w2)
h = max(h1,h2)
#visible aspect ratio
ar_vis = float(w)/float(h)
#make numpy arrays and append 1 for linear algebra
m1 = np.array((p[0][0],p[0][1],1)).astype('float32')
m2 = np.array((p[1][0],p[1][1],1)).astype('float32')
m3 = np.array((p[2][0],p[2][1],1)).astype('float32')
m4 = np.array((p[3][0],p[3][1],1)).astype('float32')
#calculate the focal disrance
k2 = np.dot(np.cross(m1,m4),m3) / np.dot(np.cross(m2,m4),m3)
k3 = np.dot(np.cross(m1,m4),m2) / np.dot(np.cross(m3,m4),m2)
n2 = k2 * m2 - m1
n3 = k3 * m3 - m1
n21 = n2[0]
n22 = n2[1]
n23 = n2[2]
n31 = n3[0]
n32 = n3[1]
n33 = n3[2]
f = math.sqrt(np.abs( (1.0/(n23*n33)) * ((n21*n31 - (n21*n33 + n23*n31)*u0 + n23*n33*u0*u0) + (n22*n32 - (n22*n33+n23*n32)*v0 + n23*n33*v0*v0))))
A = np.array([[f,0,u0],[0,f,v0],[0,0,1]]).astype('float32')
At = np.transpose(A)
Ati = np.linalg.inv(At)
Ai = np.linalg.inv(A)
#calculate the real aspect ratio
ar_real = math.sqrt(np.dot(np.dot(np.dot(n2,Ati),Ai),n2)/np.dot(np.dot(np.dot(n3,Ati),Ai),n3))
if ar_real < ar_vis:
W = int(w)
H = int(W / ar_real)
else:
H = int(h)
W = int(ar_real * H)
pts1 = np.array(p).astype('float32')
pts2 = np.float32([[0,0],[W,0],[0,H],[W,H]])
#project the image with the new w/h
M = cv2.getPerspectiveTransform(pts1,pts2)
dst = cv2.warpPerspective(img,M,(W,H))
cv2.imshow('img',img)
cv2.imshow('dst',dst)
cv2.imwrite('orig.png',img)
cv2.imwrite('proj.png',dst)
cv2.waitKey(0)
原文：
已投影（分辨率非常低，因为我从您的屏幕截图中裁剪了图像，但纵横比似乎正确）：
感谢 y300 和这个 post 我在 Java 中实现了它。我会把它留在这里，以防有人遇到与我将其转换为 Java...
时相同的问题
public float getRealAspectRatio(int imageWidth, int imageHeight) {
double u0 = imageWidth/2;
double v0 = imageHeight/2;
double m1x = mTopLeft.x - u0;
double m1y = mTopLeft.y - v0;
double m2x = mTopRight.x - u0;
double m2y = mTopRight.y - v0;
double m3x = mBottomLeft.x - u0;
double m3y = mBottomLeft.y - v0;
double m4x = mBottomRight.x - u0;
double m4y = mBottomRight.y - v0;
double k2 = ((m1y - m4y)*m3x - (m1x - m4x)*m3y + m1x*m4y - m1y*m4x) /
((m2y - m4y)*m3x - (m2x - m4x)*m3y + m2x*m4y - m2y*m4x) ;
double k3 = ((m1y - m4y)*m2x - (m1x - m4x)*m2y + m1x*m4y - m1y*m4x) /
((m3y - m4y)*m2x - (m3x - m4x)*m2y + m3x*m4y - m3y*m4x) ;
double f_squared =
-((k3*m3y - m1y)*(k2*m2y - m1y) + (k3*m3x - m1x)*(k2*m2x - m1x)) /
((k3 - 1)*(k2 - 1)) ;
double whRatio = Math.sqrt(
(Math.pow((k2 - 1),2) + Math.pow((k2*m2y - m1y),2)/f_squared + Math.pow((k2*m2x - m1x),2)/f_squared) /
(Math.pow((k3 - 1),2) + Math.pow((k3*m3y - m1y),2)/f_squared + Math.pow((k3*m3x - m1x),2)/f_squared)
) ;
if (k2==1 && k3==1 ) {
whRatio = Math.sqrt(
(Math.pow((m2y-m1y),2) + Math.pow((m2x-m1x),2)) /
(Math.pow((m3y-m1y),2) + Math.pow((m3x-m1x),2)));
}
return (float)(whRatio);
}
我最近在 Android[= 的应用程序 OpenCV 中实现了 Perspective Transform 40=]。几乎所有的事情都没有问题，但有一方面需要做更多的工作。
问题是我不知道如何计算Perspective Transform目标图像的正确宽高比（不必手动设置），以便它可以计算图像的宽高比真实尺寸 thing/image 尽管相机的角度 。注意起始坐标不是梯形，是四边形
如果我有一张从大约 45 度角拍摄的书的照片，并且我希望目标图像的纵横比与这本书的纵横比几乎相同。 2D 照片很难做到，但 CamScanner 应用程序可以完美地做到这一点。我用非常简单的方法来计算目标图像的大小（没有期望它能按我的意愿工作），但它使 45 度角的图像缩短了约 20%，并且当降低角度时图像高度降低重要的是，尽管 CamScanner 完美地完成了角度：
这里，CamScanner 将目标图像（第二张）的纵横比保持为与书本相同的纵横比，即使在约 20 度角时也能相当准确。
同时，我的代码看起来像这样（在计算目标图像的大小时我无意让它像我在这个问题中问的那样工作）：
public static Mat PerspectiveTransform(Point[] cropCoordinates, float ratioW, float ratioH, Bitmap croppedImage)
{
if (cropCoordinates.length != 4) return null;
double width1, width2, height1, height2, avgw, avgh;
Mat src = new Mat();
List<Point> startCoords = new ArrayList<>();
List<Point> resultCoords = new ArrayList<>();
Utils.bitmapToMat(croppedImage, src);
for (int i = 0; i < 4; i++)
{
if (cropCoordinates[i].y < 0 ) new Point(cropCoordinates[i].x, 0);
startCoords.add(new Point(cropCoordinates[i].x * ratioW, cropCoordinates[i].y * ratioH));
}
width1 = Math.sqrt(Math.pow(startCoords.get(2).x - startCoords.get(3).x,2) + Math.pow(startCoords.get(2).y - startCoords.get(3).y,2));
width2 = Math.sqrt(Math.pow(startCoords.get(1).x - startCoords.get(0).x,2) + Math.pow(startCoords.get(1).y - startCoords.get(0).y,2));
height1 = Math.sqrt(Math.pow(startCoords.get(1).x - startCoords.get(2).x, 2) + Math.pow(startCoords.get(1).y - startCoords.get(2).y, 2));
height2 = Math.sqrt(Math.pow(startCoords.get(0).x - startCoords.get(3).x, 2) + Math.pow(startCoords.get(0).y - startCoords.get(3).y, 2));
avgw = (width1 + width2) / 2;
avgh = (height1 + height2) / 2;
resultCoords.add(new Point(0, 0));
resultCoords.add(new Point(avgw-1, 0));
resultCoords.add(new Point(avgw-1, avgh-1));
resultCoords.add(new Point(0, avgh-1));
Mat start = Converters.vector_Point2f_to_Mat(startCoords);
Mat result = Converters.vector_Point2d_to_Mat(resultCoords);
start.convertTo(start, CvType.CV_32FC2);
result.convertTo(result,CvType.CV_32FC2);
Mat mat = new Mat();
Mat perspective = Imgproc.getPerspectiveTransform(start, result);
Imgproc.warpPerspective(src, mat, perspective, new Size(avgw, avgh));
return mat;
}
从相对相同的角度来看，我的方法产生了这个结果：
我想知道这是怎么做到的？我很感兴趣他们是如何通过坐标为 4 来计算物体的长度的角落。另外，如果可能的话，请提供一些代码/数学解释或similar/same东西的文章。
提前谢谢你。
这个问题之前在 SO 上出现过几次，但我从来没有看到完整的答案，所以就这样吧。此处显示的实现基于本文，该论文导出了完整的方程式：http://research.microsoft.com/en-us/um/people/zhang/papers/tr03-39.pdf
本质上，它表明假设一个针孔相机模型，可以计算投影矩形的纵横比（但不是比例，这不足为奇）。本质上，可以解决焦距，然后得到纵横比。这是 python 中使用 OpenCV 的示例实现。请注意，您需要以正确的顺序检测到 4 个角，否则它将不起作用（注意顺序，它是一个锯齿形）。报告的错误率在 3-5% 的范围内。
import math
import cv2
import scipy.spatial.distance
import numpy as np
img = cv2.imread('img.png')
(rows,cols,_) = img.shape
#image center
u0 = (cols)/2.0
v0 = (rows)/2.0
#detected corners on the original image
p = []
p.append((67,74))
p.append((270,64))
p.append((10,344))
p.append((343,331))
#widths and heights of the projected image
w1 = scipy.spatial.distance.euclidean(p[0],p[1])
w2 = scipy.spatial.distance.euclidean(p[2],p[3])
h1 = scipy.spatial.distance.euclidean(p[0],p[2])
h2 = scipy.spatial.distance.euclidean(p[1],p[3])
w = max(w1,w2)
h = max(h1,h2)
#visible aspect ratio
ar_vis = float(w)/float(h)
#make numpy arrays and append 1 for linear algebra
m1 = np.array((p[0][0],p[0][1],1)).astype('float32')
m2 = np.array((p[1][0],p[1][1],1)).astype('float32')
m3 = np.array((p[2][0],p[2][1],1)).astype('float32')
m4 = np.array((p[3][0],p[3][1],1)).astype('float32')
#calculate the focal disrance
k2 = np.dot(np.cross(m1,m4),m3) / np.dot(np.cross(m2,m4),m3)
k3 = np.dot(np.cross(m1,m4),m2) / np.dot(np.cross(m3,m4),m2)
n2 = k2 * m2 - m1
n3 = k3 * m3 - m1
n21 = n2[0]
n22 = n2[1]
n23 = n2[2]
n31 = n3[0]
n32 = n3[1]
n33 = n3[2]
f = math.sqrt(np.abs( (1.0/(n23*n33)) * ((n21*n31 - (n21*n33 + n23*n31)*u0 + n23*n33*u0*u0) + (n22*n32 - (n22*n33+n23*n32)*v0 + n23*n33*v0*v0))))
A = np.array([[f,0,u0],[0,f,v0],[0,0,1]]).astype('float32')
At = np.transpose(A)
Ati = np.linalg.inv(At)
Ai = np.linalg.inv(A)
#calculate the real aspect ratio
ar_real = math.sqrt(np.dot(np.dot(np.dot(n2,Ati),Ai),n2)/np.dot(np.dot(np.dot(n3,Ati),Ai),n3))
if ar_real < ar_vis:
W = int(w)
H = int(W / ar_real)
else:
H = int(h)
W = int(ar_real * H)
pts1 = np.array(p).astype('float32')
pts2 = np.float32([[0,0],[W,0],[0,H],[W,H]])
#project the image with the new w/h
M = cv2.getPerspectiveTransform(pts1,pts2)
dst = cv2.warpPerspective(img,M,(W,H))
cv2.imshow('img',img)
cv2.imshow('dst',dst)
cv2.imwrite('orig.png',img)
cv2.imwrite('proj.png',dst)
cv2.waitKey(0)
原文：
已投影（分辨率非常低，因为我从您的屏幕截图中裁剪了图像，但纵横比似乎正确）：
感谢 y300 和这个 post 我在 Java 中实现了它。我会把它留在这里，以防有人遇到与我将其转换为 Java...
时相同的问题public float getRealAspectRatio(int imageWidth, int imageHeight) {
double u0 = imageWidth/2;
double v0 = imageHeight/2;
double m1x = mTopLeft.x - u0;
double m1y = mTopLeft.y - v0;
double m2x = mTopRight.x - u0;
double m2y = mTopRight.y - v0;
double m3x = mBottomLeft.x - u0;
double m3y = mBottomLeft.y - v0;
double m4x = mBottomRight.x - u0;
double m4y = mBottomRight.y - v0;
double k2 = ((m1y - m4y)*m3x - (m1x - m4x)*m3y + m1x*m4y - m1y*m4x) /
((m2y - m4y)*m3x - (m2x - m4x)*m3y + m2x*m4y - m2y*m4x) ;
double k3 = ((m1y - m4y)*m2x - (m1x - m4x)*m2y + m1x*m4y - m1y*m4x) /
((m3y - m4y)*m2x - (m3x - m4x)*m2y + m3x*m4y - m3y*m4x) ;
double f_squared =
-((k3*m3y - m1y)*(k2*m2y - m1y) + (k3*m3x - m1x)*(k2*m2x - m1x)) /
((k3 - 1)*(k2 - 1)) ;
double whRatio = Math.sqrt(
(Math.pow((k2 - 1),2) + Math.pow((k2*m2y - m1y),2)/f_squared + Math.pow((k2*m2x - m1x),2)/f_squared) /
(Math.pow((k3 - 1),2) + Math.pow((k3*m3y - m1y),2)/f_squared + Math.pow((k3*m3x - m1x),2)/f_squared)
) ;
if (k2==1 && k3==1 ) {
whRatio = Math.sqrt(
(Math.pow((m2y-m1y),2) + Math.pow((m2x-m1x),2)) /
(Math.pow((m3y-m1y),2) + Math.pow((m3x-m1x),2)));
}
return (float)(whRatio);
}