Возможно ли преобразовать карты объектов в байты?

Question

Python 3,6

Unity 2019

Я пытаюсь найти лучшее решение для перевода данных карт объектов в единство.

Я хочу отправить данные в байтах. Однако я не нашел, как закодировать его в байты и после этого декодировать в единицу.

В основном это 4d массив, который должен быть преобразован в байтах в зависимости от того, как я его понимаю

Python piece

for fmap in feature_maps:
            bytes = []
            bytes.append(fmap)
            arrays_of_features.append(bytes)

        data = np.array(arrays_of_features, dtype=float) # this is not working because of the fact is multidimensional array apparently. 
        print(fmap)
        c.sendall(data.tobytes())

Unity piece: byte [] bytes = new byte [4000]; int idxUsedBytes = client.Receive (bytes);

    floatsReceived = new float[idxUsedBytes / 4];
    Buffer.BlockCopy(bytes, 0, floatsReceived, 0, idxUsedBytes);
    print(floatsReceived[0]);

Вдохновение: Как заставить c# в Unity взаимодействовать с Python

Карта объектов выглядит как то так:

[[[[ 0.          0.          0.         ...  0.         12.569366
 0.        ]
[ 0.          0.          0.         ...  0.          4.421044
 0.        ]
[ 0.          0.          0.         ...  0.          0.19193476
 0.        ]
...
[ 0.          0.          0.         ...  0.          0.
 0.        ]
[ 0.          0.          0.         ...  0.          0.
 0.        ]
[ 0.          0.          0.         ...  0.          0.
 0.        ]]

[[ 0.          0.          0.         ...  0.         12.910363
 0.        ]
[ 0.          0.          0.         ...  0.          3.987629
 0.        ]
[ 0.          0.          0.         ...  0.          1.6041028
 0.        ]
...
[ 0.          0.          0.         ...  0.          0.
 0.        ]
[ 0.          0.          0.         ...  0.          0.
 0.        ]
[ 0.          0.          0.         ...  0.          0.
 0.        ]]

[[ 0.          0.          0.         ...  0.          0.
 0.        ]
[ 0.          0.          0.         ...  0.          0.
 0.        ]
[ 0.          0.          0.         ...  0.          0.
 0.        ]
 ...
[ 0.          0.          0.         ...  0.          0.
 0.        ]
[ 0.          0.          0.         ...  0.          0.
 0.        ]
[ 0.          0.          0.         ...  0.          0.
 0.        ]]

...

[[ 0.          0.          0.         ...  0.          0.
 0.        ]
[ 0.          0.          0.         ...  0.          0.
 0.        ]
[ 0.          0.          0.         ...  0.          0.
 0.        ]
...
[ 0.          0.          0.         ...  0.          0.
49.52598   ]
[ 0.          0.          0.         ...  0.          0.
10.050183  ]
[ 0.          0.          0.         ...  0.          9.6911745
 0.        ]]
[[ 0.          0.          0.         ...  0.          0.
 0.        ]
[ 0.          0.          0.         ...  0.          0.
 0.        ]
[ 0.          0.          0.         ...  0.          0.
 0.        ]
...
[ 0.          0.          0.         ...  0.          0.
29.483086  ]
[ 0.          0.          0.         ...  0.          0.
24.422682  ]
[ 0.          0.          2.253025   ...  0.          0.
15.935954  ]]

[[ 0.          0.          0.         ...  0.          0.
 0.        ]
[ 0.          0.          0.         ...  0.          0.
 0.        ]
[ 0.          0.         18.458588   ... 15.824303    0.
 0.        ]
 ...
[ 0.          0.          0.         ... 25.163502   56.87079
42.9939    ]
[ 0.          0.         11.397255   ... 36.644962   17.04247
44.108196  ]
[ 0.          0.         33.134758   ... 30.220499    8.817273
36.6427    ]]]]

Answer 1

Ваш вопрос очень неясен, я думаю, вы не понимаете, как работает numpy. Если так, давайте объясним некоторые вещи. Массив из numpy - это не что иное, как строка байтов в памяти. В частности, когда эти байты отображаются для вас, они интерпретируются dtype. Тип dtype используется не для хранения базовых данных, а только для их отображения. Следовательно, изменение dtype изменяет только то, как выглядят данные, но не изменяет сами данные. То же самое для размеров. Размеры данных только изменяют способ отображения и доступа к ним; python фактически не перемещает данные и не изменяет сами данные. Например,

import numpy as np

x = np.array([[1,2,3],[4,5,6]],dtype='int64') #48 bytes, each int takes up 8 bytes.
print(x)
x.dtype = 'int32'
print(x)
x.dtype = 'float'
print(x)
x.dtype = 'int16'
print(x)

Обратите внимание, что мы можем изменить dtype, и вычисление абсолютного нуля выполняется массивом (поскольку базовые данные уже являются массивом байтов). Аналогичным образом мы можем изменить форму, и абсолютно нулевые вычисления также выполняются.

x.shape = (2,2,6)
print(x)

Форма и тип не имеют ничего общего с сохраненными данными в памяти. Надеюсь, это прояснит, как мы можем работать с массивом в байтах.

x = np.array([[1,2,3],[4,5,6]],dtype='int64')
print(x)
y = x.tobytes()

# Send y somewhere. Save to a file. Etc.

z = np.frombuffer(y)
z.dtype = 'int64'
z.shape = (2,3)
print(z)