SBData.h

Go to the documentation of this file.

 
#pragma once
#pragma warning( disable : 4251)
 
#include "SBSDK_API.h"
#include "SBTypes.h"
#include <memory>
#include <vector>
 
 
 
 
namespace PLG {
    struct PLGImage;
    struct PLGMesh;
    struct PLGCalib;
    struct PLGScan;
}
 
 
namespace SBSDK3 
{
    class SBSDK_API SBImage
    {
    public:
        SBImage();
 
        virtual ~SBImage();
        uint32_t width();
        uint32_t height();
        size_t size();
        uint32_t bytePerPixel();
        uint8_t* data();
 
        SBCameraIDEnums CameraID();
 
        bool save(const char* fileName);
 
        std::shared_ptr<PLG::PLGImage> mpPLGImg;
 
    private:
        friend class USBScanner;
        friend class Emulator;
        friend class GigEScanner;
        SBImage(std::shared_ptr<PLG::PLGImage> PLGImg, SBCameraIDEnums id);
 
        SBCameraIDEnums mCamID = SBCameraIDEnums::NONE;
    };
    class SBSDK_API SBImageList
    {
    public:
        SBImageList();
        virtual ~SBImageList();
        SBImage& operator [](int idx);
        size_t size();
        void push_back(SBImage& img);
        void clear();
 
    private:
        std::vector<SBImage> images;
    };
 
    class SBSDK_API SBCalib
    {
    public:
        SBCalib();
 
        virtual ~SBCalib();
 
        void setText(const char* text, size_t size);
 
        void setBinary(uint8_t* bin, size_t size);
 
        void setZFilter(float zNear, float zFar);
 
        void getZFilter(float& zNear, float& zFar);
 
        void setCalibBoardSize(float boardSize);
 
        float getCalibBoardSize();
 
        size_t getBinarySize();
 
        uint8_t* getBinary();
 
        bool save(const char* fileName);
 
        bool load(const char* fileName);
 
        bool exportXML(const char* fileName);
 
 
    public:
        std::shared_ptr<PLG::PLGCalib> mpPLGCalib;
        //std::shared_ptr<PLGTextureCalib> mpPLGTextureCalib
    };
 
    class SBSDK_API SBScan
    {
    public:
        SBScan();
        virtual ~SBScan();
        bool save(const char* fileName);
        bool load(const char* fileName);
        uint32_t getNumImages();
        void getCameraImages(int camIdx, SBImageList& imageList);
        bool getTextureImage(SBImage& img);
 
        bool empty();
 
        std::shared_ptr<PLG::PLGScan> mpPLGScan;
        std::shared_ptr<PLG::PLGCalib> mpPLGCalib;
        std::shared_ptr<PLG::PLGCalib> mpPLGTextureCalib;
    };
 
    class SBSDK_API SBTransform {
    friend class SBMesh;
    private:
        static const int MAT_SIZE = 16;
    public:     
        SBTransform(const float mat[MAT_SIZE]);
        ~SBTransform();     
 
        float mMat[MAT_SIZE];           
    };
 
 
    class SBSDK_API SBMesh
    {
    public:
        SBMesh();
        virtual ~SBMesh();
        size_t getNumVertices();
        void getVertices(SBVector* vertexArray);
        size_t getNumNormals();
        void getNormals(SBVector* normalArray);
        size_t getNumFaces();
        void getFaces(SBFace* faceArray);
        size_t getNumVertexColors();
        void getVertexColors(SBColor* colorArray);
 
        size_t getNumUVs();
 
        void getUVs(SBUv* uvArray);
 
        bool getTextureImage(SBImage& img);
 
        bool save(const char* fileName);
        bool applyTransform(const SBTransform& transform);
 
        bool empty();
 
    public:
        std::shared_ptr<PLG::PLGMesh> mpPLGMesh;
        SBImage mTextureImage;
        SBImage mVImage;
    };  
}