Kinect для Windows v2 глубину для рассогласования цветного изображения

Ответ 1

Наконец, я получаю некоторое время, чтобы написать долгожданный ответ.

Давайте начнем с некоторой теории, чтобы понять, что на самом деле происходит, а затем и возможный ответ.

Мы должны начать с того, что узнаем способ перехода от облака 3D-точки, у которого есть камера глубины, как исходная система координат, к изображению на плоскости изображения камеры RGB. Для этого достаточно использовать модель камеры:

Здесь u и v - это координаты в плоскости изображения камеры RGB. первой матрицей в правой части уравнения является матрица камеры, встроенная функция AKA камеры RGB. Следующая матрица - это поворот и перевод внешних признаков или, лучше сказать, преобразование, необходимое для перехода от системы координат камеры глубины к системе координат камеры RGB. Последняя часть представляет собой трехмерную точку.

В принципе, что-то вроде этого, что делает Kinect SDK. Итак, что может пойти не так, что рука будет дублироваться? ну, на самом деле более одного пункта проектируется на один и тот же пиксель....

Иными словами, в контексте проблемы в вопросе.

Изображение глубины, представляет собой представление упорядоченного облака точек, и я запрашиваю значения u v каждого из своих пикселей, которые в реальности могут быть легко преобразованы в трехмерные точки. SDK дает вам проекцию, но может указывать на один и тот же пиксель (обычно, большее расстояние в оси z между двумя соседними точками может дать эту проблему довольно легко.

Теперь, большой вопрос, как вы можете избежать этого.... ну, я не уверен в использовании Kinect SDK, так как вы не знаете значения Z точек после того, как внешние приложения применяются, так что это не можно использовать такую ​​технику, как Z buffering.... Однако вы можете предположить, что значение Z будет очень похожим и использовать те из оригинал pointcloud (на свой страх и риск).

Если вы делали это вручную, а не с помощью SDK, вы можете применять Extrinsics к точкам, а использовать проект в плоскости изображения, отмечая в другой матрице, какая точка отображается на какой пиксель, и если - это уже существующая точка, которая уже отображена, проверяет значения z и сравнивает их, и всегда оставляйте ближайшую точку к камере. Тогда у вас будет корректное отображение без каких-либо проблем. Этот путь - наивный способ, возможно, вы можете стать лучше, поскольку проблема теперь ясна:)

Я надеюсь, что это достаточно ясно.

P.S.: На данный момент у меня нет Kinect 2, поэтому я не могу попытаться выяснить, есть ли обновление относительно этой проблемы или все еще происходит одно и то же. Я использовал первую выпущенную версию (не предварительную версию) SDK... Итак, могло произойти много изменений... Если кто-то знает, если это было решение, просто оставьте комментарий:)

Ответ 2

Я предлагаю вам использовать BodyIndexFrame для определения того, принадлежит ли определенное значение игроку или нет. Таким образом, вы можете отклонить любой пиксель RGB, который не принадлежит игроку, и сохранить остальные. Я не думаю, что CoordinateMapper лежит.

Несколько примечаний:

• Включите источник BodyIndexFrame в устройство чтения фреймов.
• Используйте MapColorFrameToDepthSpace вместо MapDepthFrameToColorSpace; таким образом, вы получите изображение HD для переднего плана.
• Найдите соответствующие DepthSpacePoint и depспасибо, depthY, вместо ColorSpacePoint и colorX, colorY

Вот мой подход, когда кадр приходит (он в С#):

depthFrame.CopyFrameDataToArray(_depthData);
colorFrame.CopyConvertedFrameDataToArray(_colorData, ColorImageFormat.Bgra);
bodyIndexFrame.CopyFrameDataToArray(_bodyData);

_coordinateMapper.MapColorFrameToDepthSpace(_depthData, _depthPoints);

Array.Clear(_displayPixels, 0, _displayPixels.Length);

for (int colorIndex = 0; colorIndex < _depthPoints.Length; ++colorIndex)
{
    DepthSpacePoint depthPoint = _depthPoints[colorIndex];

    if (!float.IsNegativeInfinity(depthPoint.X) && !float.IsNegativeInfinity(depthPoint.Y))
    {
        int depthX = (int)(depthPoint.X + 0.5f);
        int depthY = (int)(depthPoint.Y + 0.5f);

        if ((depthX >= 0) && (depthX < _depthWidth) && (depthY >= 0) && (depthY < _depthHeight))
        {
            int depthIndex = (depthY * _depthWidth) + depthX;
            byte player = _bodyData[depthIndex];

            // Identify whether the point belongs to a player
            if (player != 0xff)
            {
                int sourceIndex = colorIndex * BYTES_PER_PIXEL;

                _displayPixels[sourceIndex] = _colorData[sourceIndex++];    // B
                _displayPixels[sourceIndex] = _colorData[sourceIndex++];    // G
                _displayPixels[sourceIndex] = _colorData[sourceIndex++];    // R
                _displayPixels[sourceIndex] = 0xff;                         // A
            }
        }
    }
}

Вот инициализация массивов:

BYTES_PER_PIXEL = (PixelFormats.Bgr32.BitsPerPixel + 7) / 8;

_colorWidth = colorFrame.FrameDescription.Width;
_colorHeight = colorFrame.FrameDescription.Height;
_depthWidth = depthFrame.FrameDescription.Width;
_depthHeight = depthFrame.FrameDescription.Height;
_bodyIndexWidth = bodyIndexFrame.FrameDescription.Width;
_bodyIndexHeight = bodyIndexFrame.FrameDescription.Height;
_depthData = new ushort[_depthWidth * _depthHeight];
_bodyData = new byte[_depthWidth * _depthHeight];
_colorData = new byte[_colorWidth * _colorHeight * BYTES_PER_PIXEL];
_displayPixels = new byte[_colorWidth * _colorHeight * BYTES_PER_PIXEL];
_depthPoints = new DepthSpacePoint[_colorWidth * _colorHeight];

Обратите внимание, что массив _depthPoints имеет размер 1920x1080.

Еще раз, самое главное - использовать источник BodyIndexFrame.