问题是您正在应用的算法，取自https://www.pyimagesearch.com/2017/02/20/text-skew-correction-opencv-python/是专门为文本设计的，如相同的页：

在那篇文章中使用的图像中，事实证明所有“墨水”像素都在一个矩形内，而该矩形正是代码所要寻找的：

coords = np.column_stack(np.where(thresh > 0))
angle = cv2.minAreaRect(coords)[-1]

基本上，该代码所做的是检测哪个矩形只会留下非墨水像素。它会找到的矩形将是我在此处用红色标记的矩形：

一旦找到矩形，就很容易找到它的角度并用它来拉直文本。

不幸的是，这个技巧对你不起作用，因为“墨水”像素分散在整个页面上，特别是在图像的角落附近有很多黑色像素。因此，在您的情况下，包含墨水的最小矩形是等于整个页面的矩形。这就是零角度出现的原因。

另一方面，你的case有一个很有意思的特点，就是因为是打印出来的表格，所以里面包含了大量的横线（表格的网格）。

使用霍夫变换，我们可以找到所有这些线。这种变换为每条线提供了它与水平线形成的角度。实际上，我会在您的图像中找到很多线条，其中大部分是水平的，但也有一些垂直的。例如，如果您将自己限制为超过 1000 像素的线条，您可能会发现：

（线条没有完全画出来，只画了一条，以免完全覆盖原来的线）。

Vemos que en algunas zonas (las barras negras anchas) detecta un amasijo de líneas con ángulos variables. Eso podríamos haberlo mejorado si antes de pasarle la imagen hacemos una detección de bordes (ej: canny). Pero no importa mucho en este caso porque el resto de las líneas finas las ha encontrado perfectamente.

Lo que podemos hacer es revisar todas las líneas que ha encontrado y quedarnos con los ángulos que más frecuentemente aparecen, que corresponderá a los de las líneas horizontales de la rejilla. Para este cometido nos viene muy bien la clase Counter del módulo estándar python collections.

El siguiente código hace todo lo antes descrito (he optado por volcar el resultado a otro fichero, en lugar de mostrarlo por pantalla, pues lo estoy ejecutando en un servidor sin terminal gráfica):

import numpy as np
import cv2

# Leer la imagen
imagen = cv2.imread('image.jpg')
# Convertirla a gris e invertirla (negativo)
gray = cv2.cvtColor(imagen, cv2.COLOR_BGR2GRAY)
gray = cv2.bitwise_not(gray)

# Aplicarle un threshold para dejarla binaria
# (los pixels serán 0 ó 255)
binaria = cv2.threshold(gray, 0, 255,
                cv2.THRESH_BINARY | cv2.THRESH_OTSU)[1]


# Usar la transformada de Hough para encontrar líneas
# en la imagen binarizada, con una resolución de medio
# grado (pi/720) y quedándose sólo con las líneas que
# alcancen puntuación de 1000 o más (que serán las
# más largas)
lineas = cv2.HoughLines(binaria, 1, np.pi/720, 1000)

# Recopilemos qué ángulos ha encontrado la transformada
# de hough para cada una de las líneas halladas
angulos = []
for linea in lineas:
    theta = linea[0][1]
    angulos.append(theta)

# Ahora contemos cuántas veces aparece cada ángulo
from collections import Counter
veces = Counter(angulos)

# Y quedémonos con el ángulo que más veces se repite
angulo = veces.most_common()[0][0]

# Cambiar el sentido de la rotación si el ángulo es mayor de 180º
if angulo > np.pi/2:
   angulo = -angulo
print("[INFO] angulo: {:.5f}".format(angulo))

# Ahora enderecemos la imagen, girando (en negativo) el ángulo detectado
(h, w) = imagen.shape[:2]
centro = (w // 2, h // 2)
M = cv2.getRotationMatrix2D(centro, -angulo, 1.0)
girada = cv2.warpAffine(imagen, M, (w, h),
            flags=cv2.INTER_CUBIC, borderMode=cv2.BORDER_REPLICATE)

# Y volcamos a disco el resultado
cv2.imwrite("corregida.jpg", girada)

Esto es lo que sale en el fichero "corregida.jpg" (he reducido a la mitad su resolución para pegarla aquí, pues Stack Overflow se quejaba del tamaño):

Actualización

Como el usuario reportó algunos casos de imágenes en las que no se giraba correctamente, estuve revisando el algoritmo. He hecho las siguientes mejoras:

1. En lugar de binarizar la imagen mediante un threshold he aplicado un filtro Canny. Esto también convierte la imagen a fondo negro y líneas blancas, pero las líneas son los bordes (cambios de blanco a negro) en la imagen original. Esto evita que las zonas donde hay franjas de tinta anchas Hough encuentre muchas líneas solapadas.
2. En lugar de quedarme con el ángulo más veces repetido, me quedo con los tres más veces repetidos y calculo su promedio.
3. 我在将角度应用于图像之前对其进行转换，从中减去 π/2，最重要的是在计算转换矩阵之前将其转换为度数。这很关键。就像以前一样（通过弧度），这是一个错误，尽管如此，而且偶然它旋转了正确的数量，这真是奇迹。

通过这些改进，我将它应用于一些图像，在不同方向旋转或不旋转，并且在所有这些图像中它都是正确的。

这是新代码（我已将其重构为一个函数）：

import numpy as np
import cv2


def estan_cercanos(a1, a2, error):
    cases = np.unwrap([a2-error, a1, a2 + error])
    return cases[0] <= cases[1] <= cases[2]

def enderezar(entrada, salida):
    # Leer la imagen
    imagen = cv2.imread(entrada)

    # Convertirla a gris y detectar bordes
    gray = cv2.cvtColor(imagen, cv2.COLOR_BGR2GRAY)
    binaria = cv2.Canny(gray,50,150,apertureSize = 3)

    # Usar la transformada de Hough para encontrar líneas
    # en la imagen binarizada, con una resolución de medio
    # grado (pi/720) y quedándose sólo con las líneas que
    # alcancen puntuación de 1000 o más (que serán las
    # más largas)
    lineas = cv2.HoughLines(binaria, 1, np.pi/720, 1000)

    # Recopilemos qué ángulos ha encontrado la transformada
    # de hough para cada una de las líneas halladas
    angulos = []
    for linea in lineas:
        rho, theta = linea[0]
        if rho<0:
            theta = -theta

        # Quedarse solo con las rayas próximas a la horizontal
        # (con un error de +-10 grados)
        if not estan_cercanos(theta, np.pi/2, np.deg2rad(10)):
           continue;

        angulos.append(theta)

    # Ahora contemos cuántas veces aparece cada ángulo
    from collections import Counter
    veces = Counter(angulos)

    # Quedémonos con los tres casos más frecuentes
    frecuentes = veces.most_common(3)

    # Y calculemos el promedio de esos tres casos
    suma = sum(angulo*repeticion for angulo,repeticion in frecuentes)
    repeticiones = sum(repeticion for angulo, repeticion in frecuentes)
    angulo = suma/repeticiones

    angulo = np.rad2deg(angulo - np.pi/2)
    print("[INFO] angulo: {:.5f}".format(angulo))

    # Ahora enderecemos la imagen, girando el ángulo detectado
    (h, w) = imagen.shape[:2]
    centro = (w // 2, h // 2)
    M = cv2.getRotationMatrix2D(centro, angulo, 1.0)

    girada = cv2.warpAffine(imagen, M, (w, h),
                flags=cv2.INTER_CUBIC, borderMode=cv2.BORDER_REPLICATE)

    # Y volcamos a disco el resultado
    cv2.imwrite(salida, girada)