template <class T> void D3D11RenderTarget::captureColorBuffer(BaseImage<T>& result, unsigned int which)
{
DXGI_FORMAT format = m_textureFormats[which];
if (format == DXGI_FORMAT_R8G8B8A8_UNORM) {
if (!std::is_same<vec4uc, T>::value) throw MLIB_EXCEPTION("incompatible image format");
}
else if (format == DXGI_FORMAT_R32G32B32A32_FLOAT) {
if (!std::is_same<vec4f, T>::value) throw MLIB_EXCEPTION("incompatible image format");
}
else {
throw MLIB_EXCEPTION("unknown image format");
}
auto &context = m_graphics->getContext();
context.CopyResource(m_captureTextures[which], m_targets[which]);
result.allocate(m_width, m_height);
D3D11_MAPPED_SUBRESOURCE resource;
UINT subresource = D3D11CalcSubresource(0, 0, 0);
HRESULT hr = context.Map(m_captureTextures[which], subresource, D3D11_MAP_READ, 0, &resource);
const BYTE *data = (BYTE *)resource.pData;
for (unsigned int y = 0; y < m_height; y++) {
memcpy(&result(0U, y), data + resource.RowPitch * y, m_width * sizeof(T));
}
context.Unmap(m_captureTextures[which], subresource);
}
void DX11CustomRenderTarget::Clear( ID3D11DeviceContext* pd3dDeviceContext, float clearDepth/* = 1.f*/ )
{
for (UINT i = 0; i < m_uNumTargets; i++)
{
if (m_TextureFormats[i] == DXGI_FORMAT_R32G32B32A32_FLOAT)
{
float clearColor[] = {-std::numeric_limits<float>::infinity(), -std::numeric_limits<float>::infinity(), -std::numeric_limits<float>::infinity(), 1.0f};
pd3dDeviceContext->ClearRenderTargetView(m_TargetsRTV[i], clearColor);
}
else if (m_TextureFormats[i] == DXGI_FORMAT_R32_FLOAT)
{
float clearColor[] = {-std::numeric_limits<float>::infinity()};
pd3dDeviceContext->ClearRenderTargetView(m_TargetsRTV[i], clearColor);
}
else if (m_TextureFormats[i] == DXGI_FORMAT_R8G8B8A8_UNORM_SRGB) {
float clearColor[] = {0};
pd3dDeviceContext->ClearRenderTargetView(m_TargetsRTV[i], clearColor);
}
else
{
throw MLIB_EXCEPTION("unknown texture format");
}
}
pd3dDeviceContext->ClearDepthStencilView( m_DepthStencilDSV, D3D11_CLEAR_DEPTH, clearDepth, 0);
}
ml::mat4f SensorDataReader::getRigidTransform(int offset) const
{
unsigned int idx = m_currFrame - 1 + offset;
if (idx >= m_sensorData->m_frames.size()) throw MLIB_EXCEPTION("invalid trajectory index " + std::to_string(idx));
const mat4f& transform = m_sensorData->m_frames[idx].getCameraToWorld();
return transform;
//return m_data.m_trajectory[idx];
}
void ml::D3D11TriMesh::updateColors(const std::vector<vec4f> &newValues) {
auto &vertices = m_triMesh.getVertices();
if (newValues.size() != vertices.size()) {
throw MLIB_EXCEPTION("vertex buffer size doesn't match");
}
for (size_t i = 0; i < newValues.size(); i++) {
vertices[i].color = newValues[i];
}
createGPU();
}
void SensorDataReader::getTrajectory(std::vector<mat4f>& trajectory) const
{
trajectory.clear();
if (!m_sensorData) return;
trajectory.resize(m_sensorData->m_frames.size());
for (unsigned int f = 0; f < m_sensorData->m_frames.size(); f++) {
trajectory[f] = m_sensorData->m_frames[f].getCameraToWorld();
if (trajectory[f][0] == -std::numeric_limits<float>::infinity())
throw MLIB_EXCEPTION("ERROR invalid transform in reference trajectory");
}
}
void CUDARayCastSDF::rayIntervalSplatting(const HashData& hashData, const HashParams& hashParams, const DepthCameraData& cameraData, const mat4f& lastRigidTransform)
{
if (hashParams.m_numOccupiedBlocks == 0) return;
if (m_params.m_maxNumVertices <= 6*hashParams.m_numOccupiedBlocks) { // 6 verts (2 triangles) per block
MLIB_EXCEPTION("not enough space for vertex buffer for ray interval splatting");
}
m_params.m_numOccupiedSDFBlocks = hashParams.m_numOccupiedBlocks;
m_params.m_viewMatrix = MatrixConversion::toCUDA(lastRigidTransform.getInverse());
m_params.m_viewMatrixInverse = MatrixConversion::toCUDA(lastRigidTransform);
//m_data.updateParams(m_params); // !!! debugging
m_rayIntervalSplatting.rayIntervalSplatting(DXUTGetD3D11DeviceContext(), hashData, cameraData, m_data, m_params, m_params.m_numOccupiedSDFBlocks*6);
}
void SensorDataReader::createFirstConnected()
{
releaseData();
std::string filename = GlobalAppState::get().s_binaryDumpSensorFile;
std::cout << "Start loading binary dump... ";
m_sensorData = new SensorData;
m_sensorData->loadFromFile(filename);
std::cout << "DONE!" << std::endl;
std::cout << *m_sensorData << std::endl;
//std::cout << "depth intrinsics:" << std::endl;
//std::cout << m_sensorData->m_calibrationDepth.m_intrinsic << std::endl;
//std::cout << "color intrinsics:" << std::endl;
//std::cout << m_sensorData->m_calibrationColor.m_intrinsic << std::endl;
RGBDSensor::init(m_sensorData->m_depthWidth, m_sensorData->m_depthHeight, std::max(m_sensorData->m_colorWidth, 1u), std::max(m_sensorData->m_colorHeight, 1u), 1);
initializeDepthIntrinsics(m_sensorData->m_calibrationDepth.m_intrinsic(0, 0), m_sensorData->m_calibrationDepth.m_intrinsic(1, 1), m_sensorData->m_calibrationDepth.m_intrinsic(0, 2), m_sensorData->m_calibrationDepth.m_intrinsic(1, 2));
initializeColorIntrinsics(m_sensorData->m_calibrationColor.m_intrinsic(0, 0), m_sensorData->m_calibrationColor.m_intrinsic(1, 1), m_sensorData->m_calibrationColor.m_intrinsic(0, 2), m_sensorData->m_calibrationColor.m_intrinsic(1, 2));
initializeDepthExtrinsics(m_sensorData->m_calibrationDepth.m_extrinsic);
initializeColorExtrinsics(m_sensorData->m_calibrationColor.m_extrinsic);
m_numFrames = (unsigned int)m_sensorData->m_frames.size();
if (m_numFrames > GlobalBundlingState::get().s_maxNumImages * GlobalBundlingState::get().s_submapSize) {
throw MLIB_EXCEPTION("sens file #frames = " + std::to_string(m_numFrames) + ", please change param file to accommodate");
//std::cout << "WARNING: sens file #frames = " << m_numFrames << ", please change param file to accommodate" << std::endl;
//std::cout << "(press key to continue)" << std::endl;
//getchar();
}
if (m_numFrames > 0 && m_sensorData->m_frames[0].getColorCompressed()) {
m_bHasColorData = true;
}
else {
m_bHasColorData = false;
}
const unsigned int cacheSize = 10;
m_sensorDataCache = new ml::SensorData::RGBDFrameCacheRead(m_sensorData, cacheSize);
}
void ml::D3D11TriMesh::initVB(GraphicsDevice &g)
{
if (m_triMesh.getVertices().size() == 0) return;
auto &device = g.castD3D11().getDevice();
size_t byteSize = sizeof(TriMeshf::Vertex) * m_triMesh.getVertices().size();
if (byteSize > std::numeric_limits<UINT>::max()) {
throw MLIB_EXCEPTION("buffer size too big " + std::to_string(byteSize) + ", while max is " + std::to_string(std::numeric_limits<UINT>::max()));
}
D3D11_BUFFER_DESC bufferDesc;
ZeroMemory( &bufferDesc, sizeof(bufferDesc) );
bufferDesc.Usage = D3D11_USAGE_DEFAULT;
bufferDesc.ByteWidth = (UINT)byteSize;
bufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
bufferDesc.CPUAccessFlags = 0;
D3D11_SUBRESOURCE_DATA data;
ZeroMemory( &data, sizeof(data) );
data.pSysMem = &m_triMesh.getVertices()[0];
D3D_VALIDATE(device.CreateBuffer( &bufferDesc, &data, &m_vertexBuffer ));
}
HRESULT BinaryDumpReader::createFirstConnected()
{
releaseData();
if (GlobalAppState::get().s_binaryDumpSensorFile.size() == 0) throw MLIB_EXCEPTION("need to specific s_binaryDumpSensorFile[0]");
std::string filename = GlobalAppState::get().s_binaryDumpSensorFile[0];
std::cout << "Start loading binary dump" << std::endl;
//BinaryDataStreamZLibFile inputStream(filename, false);
BinaryDataStreamFile inputStream(filename, false);
inputStream >> m_data;
std::cout << "Loading finished" << std::endl;
std::cout << m_data << std::endl;
std::cout << "intrinsics:" << std::endl;
std::cout << m_data.m_CalibrationDepth.m_Intrinsic << std::endl;
RGBDSensor::init(m_data.m_DepthImageWidth, m_data.m_DepthImageHeight, std::max(m_data.m_ColorImageWidth,1u), std::max(m_data.m_ColorImageHeight,1u), 1);
initializeDepthIntrinsics(m_data.m_CalibrationDepth.m_Intrinsic(0,0), m_data.m_CalibrationDepth.m_Intrinsic(1,1), m_data.m_CalibrationDepth.m_Intrinsic(0,2), m_data.m_CalibrationDepth.m_Intrinsic(1,2));
initializeColorIntrinsics(m_data.m_CalibrationColor.m_Intrinsic(0,0), m_data.m_CalibrationColor.m_Intrinsic(1,1), m_data.m_CalibrationColor.m_Intrinsic(0,2), m_data.m_CalibrationColor.m_Intrinsic(1,2));
initializeDepthExtrinsics(m_data.m_CalibrationDepth.m_Extrinsic);
initializeColorExtrinsics(m_data.m_CalibrationColor.m_Extrinsic);
m_NumFrames = m_data.m_DepthNumFrames;
assert(m_data.m_ColorNumFrames == m_data.m_DepthNumFrames || m_data.m_ColorNumFrames == 0);
if (m_data.m_ColorImages.size() > 0) {
m_bHasColorData = true;
} else {
m_bHasColorData = false;
}
return S_OK;
}
void RGBDSensor::computePointCurrentPointCloud(PointCloudf& pc, const mat4f& transform /*= mat4f::identity()*/) const
{
if (!(getColorWidth() == getDepthWidth() && getColorHeight() == getDepthHeight())) throw MLIB_EXCEPTION("invalid dimensions");
for (unsigned int i = 0; i < getDepthWidth()*getDepthHeight(); i++) {
unsigned int x = i % getDepthWidth();
unsigned int y = i / getDepthWidth();
vec3f p = depthToSkeleton(x,y);
if (p.x != -std::numeric_limits<float>::infinity() && p.x != 0.0f) {
vec3f n = getNormal(x,y);
if (n.x != -FLT_MAX) {
pc.m_points.push_back(p);
pc.m_normals.push_back(n);
vec4uc c = m_colorRGBX[i];
pc.m_colors.push_back(vec4f(c.z/255.0f, c.y/255.0f, c.x/255.0f, 1.0f)); //there's a swap... dunno why really
}
}
}
for (auto& p : pc.m_points) {
p = transform * p;
}
mat4f invTranspose = transform.getInverse().getTranspose();
for (auto& n : pc.m_normals) {
n = invTranspose * n;
n.normalize();
}
}
