DynamicInputProvider Class Reference

Inheritance diagram for DynamicInputProvider:

Public Member Functions
	DynamicInputProvider (const std::string &libraryPath, VulkanWrapper &vkw)
std::vector< StreamParameters >	enumerateStreamsParameters () const override
std::vector< StreamImage >	enumerateStreamImages (uint32_t streamIndex, bool depth) const override
void	acquireStreamsFrames (const Extrinsics &targetViewExtrinsics, std::span< StreamFrameInfo > outFrameInfos) override
void	releaseStreamsFrames () override
virtual std::vector< StreamParameters >	enumerateStreamsParameters () const =0
virtual std::vector< StreamImage >	enumerateStreamImages (uint32_t streamIndex, bool depth) const =0
virtual void	acquireStreamsFrames (const Extrinsics &targetViewExtrinsics, std::span< StreamFrameInfo > outFrameInfos)=0
virtual void	releaseStreamsFrames ()=0

Additional Inherited Members
Public Types inherited from InputProvider
enum class	ProjectionType { PROJECTION_INVALID , PROJECTION_PERSPECTIVE , PROJECTION_EQUIRECTANGULAR }
using	Intrinsics = std::variant< PerspectiveIntrinsics, EquirectangularIntrinsics >
	Union of possible intrinsics types data.

Detailed Description

Definition at line 25 of file DynamicInputProvider.h.

Constructor & Destructor Documentation

DynamicInputProvider()

DynamicInputProvider::DynamicInputProvider	(	const std::string &	libraryPath,
		VulkanWrapper &	vkw
	)

Definition at line 47 of file DynamicInputProvider.cpp.

                                                                                           : vkw(vkw)
{
  loadLibrary(libraryPath);
  init();
}

~DynamicInputProvider()

DynamicInputProvider::~DynamicInputProvider

(

)

Definition at line 517 of file DynamicInputProvider.cpp.

                                            {
  hvtCheck(hvt.stopStreaming, context);
  hvtCheck(hvt.destroyStreamingContext, context);
}

Member Function Documentation

acquireStreamsFrames()

void DynamicInputProvider::acquireStreamsFrames ( const Extrinsics &  targetViewExtrinsics, std::span< StreamFrameInfo >  outFrameInfos  )

overridevirtual

Implements InputProvider.

Definition at line 427 of file DynamicInputProvider.cpp.

                                                                                                                              {
  auto extrinsicsToHvt = [](Extrinsics ex){
    return HvtExtrinsics{
      .position = HvtPosition{
          .x = ex.position.x,
          .y = ex.position.y,
          .z = ex.position.z
      },
      .rotation = HvtRotation{
          .yaw = ex.rotation.x,
          .pitch = ex.rotation.y,
          .roll = ex.rotation.z
      }
    };
  };
 
  // Take next sync slot
  currentSyncSlot = (currentSyncSlot+1) % syncInfos.size();
  auto& currentSync = syncInfos.at(currentSyncSlot);
 
  // Get stream frame info from the module
  std::vector<HvtStreamFrameInfo> hvtFrameInfos(outFrameInfos.size());
  HvtAcquireStreamFramesInfo ainfos{
    .viewerExtrinsics = extrinsicsToHvt(targetViewExtrinsics),
    .frameInfoCount = (uint32_t)hvtFrameInfos.size(),
    .pStreamFrameInfos = hvtFrameInfos.data(),
    .signalSemaphore = currentSync.acquireHvt
  };
  hvtCheck(hvt.acquireStreamsFrames, context, &ainfos);
 
 
  //Fill the output frames info
  for(int i = 0; i < outFrameInfos.size(); i++) {
    const auto& hfi = hvtFrameInfos.at(i);
    auto& fi = outFrameInfos[i];
 
    auto ext = hfi.extrinsics;
    auto intr = hfi.intrinsics;
 
    if (cachedStreamParameters.at(i).projectionType == ProjectionType::PROJECTION_PERSPECTIVE) {
        fi = StreamFrameInfo{
            .imageIndex = hfi.imageIndex,
            .extrinsics = Extrinsics{
              .position = {ext.position.x,ext.position.y,ext.position.z},
              .rotation = {ext.rotation.yaw, ext.rotation.pitch, ext.rotation.roll}
            },
            .intrinsics = Intrinsics{ //TODO handle the equirectangular case
              PerspectiveIntrinsics{
                .focals = {hfi.intrinsics.perspective.focalX, hfi.intrinsics.perspective.focalY},
                .principle = {hfi.intrinsics.perspective.principlePointX, hfi.intrinsics.perspective.principlePointY}
              }
            }
        };
    }
    else if(cachedStreamParameters.at(i).projectionType == ProjectionType::PROJECTION_EQUIRECTANGULAR) {
        fi = StreamFrameInfo{
            .imageIndex = hfi.imageIndex,
            .extrinsics = Extrinsics{
              .position = {ext.position.x,ext.position.y,ext.position.z},
              .rotation = {ext.rotation.yaw, ext.rotation.pitch, ext.rotation.roll}
            },
            .intrinsics = Intrinsics{ 
              EquirectangularIntrinsics{
                .verticalRange = {hfi.intrinsics.equirectangular.verticalRange[0], hfi.intrinsics.equirectangular.verticalRange[1]},
                .horizontalRange = {hfi.intrinsics.equirectangular.horizontalRange[0], hfi.intrinsics.equirectangular.horizontalRange[1]}
              }
            }
        };
    }
    else {
        throw std::runtime_error("Invalid projection type !");
    }
  }
 
  //Wait on the image sempahore
  vk::PipelineStageFlags waitStage = vk::PipelineStageFlagBits::eTopOfPipe;
  vkw.context.graphicsQueue.submit(
        vk::SubmitInfo(*currentSync.acquireSemaphore, waitStage));
}

enumerateStreamImages()

std::vector< DynamicInputProvider::StreamImage > DynamicInputProvider::enumerateStreamImages ( uint32_t  streamIndex, bool  depth  ) const

overridevirtual

Implements InputProvider.

Definition at line 418 of file DynamicInputProvider.cpp.

                                                                                                                             {
  const auto& stream = streamStorage.at(streamIndex);
  if(depth) {
    return stream.depthImages;
  } else {
    return stream.colorImages;
  }
}

enumerateStreamsParameters()

std::vector< DynamicInputProvider::StreamParameters > DynamicInputProvider::enumerateStreamsParameters ( ) const

overridevirtual

Implements InputProvider.

Definition at line 414 of file DynamicInputProvider.cpp.

                                                                                                       {
  return cachedStreamParameters;
}

releaseStreamsFrames()

void DynamicInputProvider::releaseStreamsFrames ( )

overridevirtual

Implements InputProvider.

Definition at line 507 of file DynamicInputProvider.cpp.

                                                {
  auto& currentSync = syncInfos.at(currentSyncSlot);
 
  // Submit a signal that we are done with the image
  vkw.context.graphicsQueue.submit(
        vk::SubmitInfo({},{},{},*currentSync.releaseSempahore));
 
  hvtCheck(hvt.releaseStreamsFrames, context, currentSync.releaseHvt); //TODO pass proper semaphore
}

---

The documentation for this class was generated from the following files:

• DynamicInputProvider.h
• DynamicInputProvider.cpp