cxVNNclAlgorithm.h

Go to the documentation of this file.

/*=========================================================================
This file is part of CustusX, an Image Guided Therapy Application.
                 
Copyright (c) SINTEF Department of Medical Technology.
All rights reserved.
                 
CustusX is released under a BSD 3-Clause license.
                 
See Lisence.txt (https://github.com/SINTEFMedtek/CustusX/blob/master/License.txt) for details.
=========================================================================*/

#ifndef CXVNNCLALGORITHM_H_
#define CXVNNCLALGORITHM_H_

//TODO remove, should be defined in oul instead
#define __CL_ENABLE_EXCEPTIONS //telling the opencl c++ wrapper to throw exceptions

#include "cxUSFrameData.h"
#include "OpenCLManager.hpp"
#include "RuntimeMeasurementManager.hpp"

namespace cx
{
class VNNclAlgorithm
{
public:
        VNNclAlgorithm();
        ~VNNclAlgorithm();

        typedef struct __frameBlock_t
        {
                unsigned char* data;
                size_t length;
        } frameBlock_t;

        virtual bool initCL(QString kernelFile,
                            int nMaxPlanes,
                            int nPlanes,
                            int method,
                            int planeMethod,
                            int nStarts,
                            float brightnessWeight,
                            float newnessWeight);
        virtual cl::Program buildCLProgram(std::string program_src,
                                                                           std::string kernelPath,
                                          int nMaxPlanes,
                                          int nPlanes,
                                          int method,
                                          int planeMethod,
                                          int nStarts,
                                          float brightnessWeight,
                                          float newnessWeight);
        virtual bool reconstruct(ProcessedUSInputDataPtr input,
                                      vtkImageDataPtr outputData,
                                      float radius,
                                      int nClosePlanes);

        virtual bool initializeFrameBlocks(frameBlock_t* framePointers,
                                           int numBlocks,
                                           ProcessedUSInputDataPtr inputFrames);
        virtual void freeFrameBlocks(frameBlock_t* framePointers,
                                                                 int numBlocks);


        virtual void fillPlaneMatrices(float *planeMatrices,
                                       ProcessedUSInputDataPtr input);

        void setProfiling(bool on);
        double getTotalExecutionTime();
        double getKernelExecutionTime();

private:
        void setKernelArguments(
                        cl::Kernel kernel,
                        int volume_xsize,
                int volume_ysize,
                int volume_zsize,
                float volume_xspacing,
                float volume_yspacing,
                float volume_zspacing,
                int in_xsize,
                int in_ysize,
                float in_xspacing,
                float in_yspacing,
                std::vector<cl::Buffer>& blocks,
                cl::Buffer out_volume,
                cl::Buffer plane_matrices,
                cl::Buffer mask,
                size_t plane_eqs_size,
                size_t close_planes_size,
                float radius);
        size_t calculateSpaceNeededForClosePlanes(cl::Kernel kernel, cl::Device device, size_t local_work_size, size_t nPlanes_numberOfInputImages, int nClosePlanes);
        bool isUsingTooMuchMemory(size_t outputVolumeSize, size_t inputBlocksLength, cl_ulong globalMemUse);
        void measureAndExecuteKernel(cl::CommandQueue queue, cl::Kernel kernel, size_t global_work_size, size_t local_work_size, std::string measurementName);
        void measureAndReadBuffer(cl::CommandQueue queue, cl::Buffer outputBuffer, size_t outputVolumeSize, void *outputData, std::string measurementName);

        void startProfiling(std::string name, cl::CommandQueue queue);
        void stopProfiling(std::string name, cl::CommandQueue queue);

        cl::Kernel mKernel;
        oul::ContextPtr mOulContex;
        oul::RuntimeMeasurementsManagerPtr mRuntime;
        std::set<std::string> mMeasurementNames;
        std::string mKernelMeasurementName;

};

typedef boost::shared_ptr<VNNclAlgorithm> VNNclAlgorithmPtr;

} /* namespace cx */
#endif /* CXVNNCLALGORITHM_H_ */