Really different matrixes in Python producing the same images

I am working on some RGB images processing. I suggest anyone who reads this to ignore the functions I've created before the main code (these are not relevant to the problem itself, I beleive).

The RGB1 image I am using is this one:

Here is my code so far:

import sys
import numpy as np
import quaternion
import matplotlib.pyplot as plt
from pandas import *
import scipy.io as spio
import matplotlib.image as img

# IGNORE UNTIL NEXT COMMENT #

np.set_printoptions(threshold=sys.maxsize)

def row_wise_fft(A):
    A = np.asarray(A)
    rowWiseFFT = np.zeros((A.shape[0], A.shape[1]), dtype='complex')
    for i in range(0, A.shape[0]):
        rowWiseFFT[i, :] = np.fft.fft(A[i, :])
    return rowWiseFFT

def row_wise_ifft(A):
    A = np.asarray(A)
    rowWiseFFT = np.zeros(A.shape, dtype='complex')
    for i in range(0, A.shape[0]):
        rowWiseFFT[i, :] = np.fft.ifft(A[i, :])
    return rowWiseFFT

def split_parts(A):
    return [A.real, A.imag]

def column_wise_fft(A):
    A = np.asarray(A)
    columnWiseFFT = np.zeros((A.shape[0], A.shape[1]), dtype='complex')
    for i in range(0, A.shape[1]):
        columnWiseFFT[:, i] = np.fft.fft(A[:, i])
    return columnWiseFFT

def final_dqft(FuvR, FuvI):
    [FuvR, FuvI] = [np.asarray(FuvR), np.asanyarray(FuvI)]
    [FuvRReal, FuvRImag] = split_parts(FuvR)
    [FuvIReal, FuvIImag] = split_parts(FuvI)
    FuvQ = [[None]*FuvR.shape[1]]*FuvR.shape[0]
    FuvQ = np.asarray(FuvQ)
    for i in range(0, FuvQ.shape[0]):
        for k in range(0, FuvQ.shape[1]):
            FuvQ[i][k] = np.quaternion(
                FuvRReal[i][k], FuvIReal[i][k], FuvRImag[i][k], FuvIImag[i][k])
    return FuvQ


def column_wise_ifftshift(A):
    columnWiseIfftshift = np.zeros((A.shape[0], A.shape[1]), dtype='complex')
    for i in range(0, A.shape[1]):
        columnWiseIfftshift[:, i] = np.fft.ifftshift(A[:, i])
    return columnWiseIfftshift

def column_wise_fftshift(A):
    columnWisefftshift = np.zeros(A.shape, dtype='complex')
    for i in range(0, A.shape[1]):
        columnWisefftshift[:, i] = np.fft.fftshift(A[:, i])
    return columnWisefftshift

def row_wise_ifftshift(A):
    rowWiseIfftshift = np.zeros((A.shape[0], A.shape[1]), dtype='complex')
    for i in range(0, len(A)):
        rowWiseIfftshift[i] = np.fft.ifftshift(A[i])
    return rowWiseIfftshift

def row_wise_fftshift(A):
    rowWisefftshift = np.zeros((A.shape[0], A.shape[1]), dtype='complex')
    for i in range(0, len(A)):
        rowWisefftshift[i] = np.fft.fftshift(A[i])
    return rowWisefftshift

def full_DQFT_calculator(A):
    fun = row_wise_fftshift(row_wise_fft(row_wise_ifftshift(A)))
    [funReal, funImag] = split_parts(fun)
    FuvR = column_wise_fftshift(
        column_wise_fft(column_wise_ifftshift(funReal)))
    FuvI = column_wise_fftshift(
        column_wise_fft(column_wise_ifftshift(funImag)))
    FuvQ = final_dqft(FuvR, FuvI)
    return FuvQ

# STOP IGNORING FROM NOW ON #

image = img.imread("RGB1.jpg")

# Keep the Red,Green and Blue Channels.
R = np.asarray(image[:, :, 0])
G = np.asarray(image[:, :, 1])
B = np.asarray(image[:, :, 2])

# Defining h_r = 0 ; h_i = Red ; h_j = Green ; h_k = Blue
(h_r, h_i, h_j, h_k) = (np.zeros(R.shape), R, G, B)

# Some intermediatte calculations
firstIntegral = full_DQFT_calculator(h_i)
secondIntegral = full_DQFT_calculator(h_j)
thirdIntegral = full_DQFT_calculator(h_k)

final_result = np.empty(firstIntegral.shape, dtype='quaternion')
for i in range(0, final_result.shape[0]):
    for j in range(0, final_result.shape[1]):
        final_result[i][j] = np.quaternion(-firstIntegral[i][j].x-secondIntegral[i][j].y+thirdIntegral[i][j].z, firstIntegral[i][j].w - secondIntegral[i][j].z - thirdIntegral[i]
                                           [j].y, secondIntegral[i][j].w - thirdIntegral[i][j].x - firstIntegral[i][j].z, firstIntegral[i][j].y + secondIntegral[i][j].x + thirdIntegral[i][j].w)

real_final_result = np.empty(final_result.shape, dtype='float')
for i in range(0, real_final_result.shape[0]):
    for j in range(0, real_final_result.shape[1]):
        real_final_result[i][j] = final_result[i][j].w
print('Parte real da primeira linha da matriz (transformada quaterniónica): \n',real_final_result[0], '\n')

i_final_result = np.empty(final_result.shape, dtype='float')
for i in range(0, i_final_result.shape[0]):
    for j in range(0, i_final_result.shape[1]):
        i_final_result[i][j] = final_result[i][j].x
print('Componente i da primeira linha da matriz (transformada quaterniónica): \n',i_final_result[0], '\n')

print(real_final_result[0] - i_final_result[0])

The difference between the two matrixes (i.e., the last print) is huge but when I try to print the matrixes using the following code:

fig = plt.figure()
plt.set_cmap('gray')

ax1 = fig.add_subplot(121)
plt.imshow(real_final_result)
plt.clim([0,1])
ax1.title.set_text('Re(TFQ)')

ax2 = fig.add_subplot(122)
plt.imshow(i_final_result)
plt.clim([0, 1])
ax2.title.set_text('I(TFQ)')

plt.show()

I obtain the exact same image. Can someone tell why is this happening?