docs/_simple_g_v_x_r_8h_source.html

/*


Copyright (c) 2019, Dr Franck P. Vidal (franck.p.vidal@fpvidal.net),

http://www.fpvidal.net/

All rights reserved.


Redistribution and use in source and binary forms, with or without modification,

are permitted provided that the following conditions are met:


1. Redistributions of source code must retain the above copyright notice,

this list of conditions and the following disclaimer.


2. Redistributions in binary form must reproduce the above copyright notice,

this list of conditions and the following disclaimer in the documentation and/or

other materials provided with the distribution.


3. Neither the name of the Bangor University nor the names of its contributors

may be used to endorse or promote products derived from this software without

specific prior written permission.


THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND

ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,

THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE

FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR

SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER

CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,

OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF

THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


*/


#ifndef __SimpleGVXR_h

#define __SimpleGVXR_h


//******************************************************************************

//  Include

//******************************************************************************

#include <vector>

#include <string>


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

int getMajorVersionOfCoreGVXR();


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

int getMinorVersionOfCoreGVXR();


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

int getPatchVersionOfCoreGVXR();


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

std::string getVersionOfCoreGVXR();


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

int getMajorVersionOfSimpleGVXR();


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

int getMinorVersionOfSimpleGVXR();


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

int getPatchVersionOfSimpleGVXR();


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

std::string getVersionOfSimpleGVXR();


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

std::string getOpenGlRenderer();


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

std::string getOpenGlVersion();


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

std::string getOpenGlVenror();


void useLogFile(const char* aFileName = "gvxr.log");


void displayBeam(bool aState = true);

void displayDetector(bool aState = true);

void displayNormalVectors(bool aState = true);

void useWireframe(bool aState = true);

void useLighing(bool aState = true);

void useNegative(bool aState = true);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void orthographic(double left,

        double right,

        double bottom,

        double top,

        double zNear,

        double zFar);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void perspective(double fovy, double aspect, double  zNear, double  zFar);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void lookAt(double eyeX,

            double eyeY,

            double eyeZ,

            double lookAtX,

            double lookAtY,

            double lookAtZ,

            double upX,

            double upY,

            double upZ);


//------------------------------------------------------------------------------

//------------------------------------------------------------------------------

void pushModelViewMatrix();


//------------------------------------------------------------------------------

//------------------------------------------------------------------------------

void popModelViewMatrix();


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void rotateModelView(double anAngle, double x, double y, double z);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void autoCreateOpenGLContext(bool aFlag = true);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void setSourcePosition(double x,

    double y,

    double z,

    const std::string& aUnitOfLength);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

std::vector<double> getSourcePosition(const std::string& aUnitOfLength);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void setDetectorPosition(double x,

    double y,

    double z,

    const std::string& aUnitOfLength);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

std::vector<double> getDetectorPosition(const std::string& aUnitOfLength);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void setDetectorUpVector(double x, double y, double z);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

std::vector<double> getDetectorUpVector();


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

std::vector<double> getDetectorRightVector();


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void setDetectorNumberOfPixels(int aWidth, int aHeight);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

std::vector<int> getDetectorNumberOfPixels();


//--------------------------------------------------------------------------


//--------------------------------------------------------------------------

void setOversamplingFactor(int aFactor = 1);


//--------------------------------------------------------------------------


//--------------------------------------------------------------------------

int getOversamplingFactor();


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void setDetectorPixelSize(double aWidth,

    double aHeight,

    const std::string& aUnitOfLength);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

std::vector<double> getDetectorSize(const std::string& aUnitOfLength);


//------------------------------------------------------------------------------

//------------------------------------------------------------------------------

void clearDetectorEnergyResponse();


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void loadDetectorEnergyResponse(const std::string& aFileName,

    const std::string& aUnitOfEnergy);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void loadMeshFile(const std::string& aLabel,

                  const std::string& aFileName,

                  const std::string& aUnitOfLength,

                  bool addToRendererAsInnerSurface = true);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void loadSceneGraph(const std::string& aFileName,

    const std::string& aUnitOfLength);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

unsigned int getNumberOfPrimitives(const std::string& aLabel);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void emptyMesh(const std::string& aLabel,

        const std::string& aParent = "root");


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void makeCube(const std::string& aLabel,

        double aLength = 1.0,

        const std::string& aUnitOfLength = "cm",

        const std::string& aParent = "root");


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void makeCylinder(const std::string& aLabel,

                  unsigned int aNumberOfSectors = 10,

                  double aHeight = 1.0,

                  double aRadius = 0.5,

                  const std::string& aUnitOfLength = "cm",

                  const std::string& aParent = "root");


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void makeIsoSurface(const std::string& aLabel,

    short anIsoValue,

    const std::vector<short>& aVoxelDataSet,

    unsigned int aWidth,

    unsigned int aHeight,

    unsigned int aDepth,

    double aSpacingX,

    double aSpacingY,

    double aSpacingZ,

    const std::string& aUnitOfLength = "cm",

    const std::string& aParent = "root");


void makeTriangularMesh(const std::string& aLabel,

        const std::vector<float>& aVertexSet,

        const std::string& aUnitOfLength = "cm",

        const std::string& aParent = "root");


void makeTriangularMesh(const std::string& aLabel,

        const std::vector<float>& aVertexSet,

        const std::vector<int>& aTriangleIndexSet,

        const std::string& aUnitOfLength = "cm",

        const std::string& aParent = "root");


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void addMesh(const std::string& aDestination, const std::string& aSource);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void subtractMesh(const std::string& aDestination, const std::string& aSource);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

unsigned int getNumberOfChildren(const std::string& aLabel);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

std::string getChildLabel(const std::string& aLabel, unsigned int i);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

std::vector<double> getLocalTransformationMatrix(const std::string& aLabel);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void setLocalTransformationMatrix(const std::string& aLabel,

    const std::vector<double>& aMatrix);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void applyCurrentLocalTransformation(const std::string& aLabel);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

std::vector<double> getNodeAndChildrenBoundingBox(const std::string& aLabel,

    const std::string& aUnitOfLength = "cm");


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

std::vector<double> getNodeOnlyBoundingBox(const std::string& aLabel,

    const std::string& aUnitOfLength = "cm");


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void displayNode(const std::string& aLabel);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void invertNormalVectors(const std::string& aLabel);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void setColor(const std::string& aLabel, float R, float G, float B, float A);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void setColour(const std::string& aLabel, float R, float G, float B, float A);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

std::vector<float> getAmbientColour(const std::string& aLabel);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

std::vector<float> getDiffuseColour(const std::string& aLabel);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

std::vector<float> getSpecularColour(const std::string& aLabel);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

float getShininess(const std::string& aLabel);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void addPolygonMeshAsInnerSurface(const std::string& aLabel);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void addPolygonMeshAsOuterSurface(const std::string& aLabel);


//------------------------------------------------------------------------------

//------------------------------------------------------------------------------

void removePolygonMeshesFromSceneGraph();


//------------------------------------------------------------------------------

//------------------------------------------------------------------------------

void removePolygonMeshesFromXRayRenderer();


//------------------------------------------------------------------------------

//------------------------------------------------------------------------------

void moveToCenter();


//------------------------------------------------------------------------------

//------------------------------------------------------------------------------

void moveToCentre();


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void moveToCenter(const std::string& aLabel);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void moveToCentre(const std::string& aLabel);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void scaleNode(const std::string& aLabel,

    double x,

    double y,

    double z);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void rotateNode(const std::string& aLabel,

    double anAngle,

    double x,

    double y,

    double z);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void translateNode(const std::string& aLabel,

    double x,

    double y,

    double z,

    const std::string& aUnitOfLength);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void shearNode(const std::string& aLabel,

               double yx,

               double zx,

               double xy,

               double zy,

               double xz,

               double yz);


//------------------------------------------------------------------------------

//------------------------------------------------------------------------------

void resetSceneTransformation();


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void scaleScene(double x, double y, double z);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void scaleScene(double x, double y, double z, const std::string& aUnitOfLength);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void rotateScene(double anAngle, double x, double y, double z);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void translateScene(double x,

                    double y,

                    double z,

                    const std::string& aUnitOfLength);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

std::vector<std::vector<float> > getSceneTransformationMatrix();


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

std::vector<std::vector<float> > getRootTransformationMatrix();


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

std::vector<std::vector<float> > getNodeLocalTransformationMatrix(

    const std::string& aLabel);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

std::vector<std::vector<float> > getNodeWorldTransformationMatrix(

    const std::string& aLabel);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void setSceneTransformationMatrix(

    const std::vector<std::vector<float> >& aMatrix);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void setRootTransformationMatrix(

    const std::vector<std::vector<float> >& aMatrix);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void setNodeTransformationMatrix(

    const std::string& aLabel,

    const std::vector<std::vector<float> >& aMatrix);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void setHU(const std::string& aLabel, short HU);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void setHounsfieldUnit(const std::string& aLabel, short HU);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void setHounsfieldValue(const std::string& aLabel, short HU);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void setElement(const std::string& aLabel, unsigned short Z);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void setElement(const std::string& aLabel, const std::string& aName);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void setMixture(const std::string& aLabel, const std::string& aMixture);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void setMixture(const std::string& aLabel,

                const std::vector<int>& aZNumberSet,

                const std::vector<double>& aWeightSet);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void setCompound(const std::string& aLabel, const std::string& aCompound);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void setMassAttenuationCoefficient(const std::string& aLabel,

                                   double aCoefficient,

                                   const std::string& aUnit);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void setLinearAttenuationCoefficient(const std::string& aLabel,

                                     double aCoefficient,

                                     const std::string& aUnit);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void setMu(const std::string& aLabel,

           double aCoefficient,

           const std::string& aUnit);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void setDensity(const std::string& aLabel,

                double aDensity,

                const std::string& aUnit);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

double getDensity(const std::string& aLabel);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

double getMassAttenuationCoefficient(const std::string& aLabel,

                                     double anEnergy,

                                     const std::string& aUnitOfEnergy);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

double getLinearAttenuationCoefficient(const std::string& aLabel,

                                       double anEnergy,

                                       const std::string& aUnitOfEnergy);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

std::string getMaterialLabel(const std::string& aLabel);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void createOpenGLContext(int aWindowID = -1,

        int aRendererMajorVersion = 3,

        int aRendererMinorVersion = 2);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void createWindow(int aWindowID = -1,

        int aVisibilityFlag = 0,

        const std::string& aRenderer = "OPENGL",

        int aRendererMajorVersion = 3,

        int aRendererMinorVersion = 2);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void setWindowSize(int aWidth, int aHeight, int aWindowID = -1);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void displayScene(bool aSceneRotationFlag = true, int aWindowID = -1);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void renderLoop(int aWindowID = -1);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void startArcBallRotation(double x, double y);


//------------------------------------------------------------------------------

//------------------------------------------------------------------------------

void stopArcBallRotation();


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

bool usingArcBallRotation();


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void cursorPositionCallback(double x,

                            double y,

                            int aViewportWidth,

                            int aViewportHeight);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void scrollCallback(double xoffset, double yoffset);


void setZoom(float aZoomValue);


float getZoom();


void setSceneRotationMatrix(const std::vector<double>& aRotationMatrix);


std::vector<double> getSceneRotationMatrix();


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void showWindow(int aWindowID = -1);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void hideWindow(int aWindowID = -1);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void setWindowBackGroundColour(float R, float G, float B, int aWindowID = -1);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void setWindowBackGroundColor(float R, float G, float B, int aWindowID = -1);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

const std::vector<std::vector<std::vector< float> > >& takeScreenshot(int aWindowID = -1);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

const std::vector<std::vector<std::vector< float> > >& getLatestScreenshot();


//------------------------------------------------------------------------------

//------------------------------------------------------------------------------

void destroyWindow(int aWindowID = -1);


//------------------------------------------------------------------------------

//------------------------------------------------------------------------------

void destroyAllWindows(void);


//------------------------------------------------------------------------------

//------------------------------------------------------------------------------

void usePointSource();


//------------------------------------------------------------------------------

//------------------------------------------------------------------------------

void useParallelBeam();


//------------------------------------------------------------------------------

//------------------------------------------------------------------------------

void useParallelSource();


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

//void setFocalSpot(x, y, z, aUnitOfLength);


//------------------------------------------------------------------------------

//------------------------------------------------------------------------------

void resetBeamSpectrum();


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void setMonoChromatic(double anEnergy,

                      const std::string& aUnitOfEnergy,

                      double aNumberOfPhotons);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void addEnergyBinToSpectrum(double anEnergy,

                            const std::string& aUnitOfEnergy,

                            double aNumberOfPhotons);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void loadSpectrumFromTSV(const std::string& aFileName,

                         const std::string& aUnitOfEnergy,

                         bool aNormalisationFlag);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

std::vector<double> getEnergyBins(const std::string& aUnitOfEnergy);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

std::vector<double> getPhotonCountEnergyBins();


//--------------------------------------------------------------------------


//--------------------------------------------------------------------------

double getTotalEnergyWithDetectorResponse();


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void saveSTLfile(const std::string& aLabel,

        const std::string& aFileName = std::string());


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void saveLastXRayImage(const std::string& aFileName = std::string(),

    bool useCompression = true);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void saveLastLBuffer(const std::string& aFileName = std::string(),

    bool useCompression = true);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void saveLastCumulatedLBuffer(const std::string& aFileName = std::string(),

    bool useCompression = true);


    //------------------------------------------------------------------------------


    //------------------------------------------------------------------------------

    void saveLastSinogram(const std::string& aFileName = std::string(),

        bool useCompression = true);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

void saveLastProjectionSet(const std::string& aFileName = std::string(),

    bool useCompression = true);


//------------------------------------------------------------------------------

//------------------------------------------------------------------------------

void enableArtefactFilteringOnGPU(void);


//------------------------------------------------------------------------------

//------------------------------------------------------------------------------

void enableArtifactFilteringOnGPU(void);


//------------------------------------------------------------------------------

//------------------------------------------------------------------------------

void enableArtefactFilteringOnCPU(void);


//------------------------------------------------------------------------------

//------------------------------------------------------------------------------

void enableArtifactFilteringOnCPU(void);


//------------------------------------------------------------------------------

//------------------------------------------------------------------------------

void disableArtefactFiltering(void);


//------------------------------------------------------------------------------

//------------------------------------------------------------------------------

void disableArtifactFiltering(void);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

double getUnitOfEnergy(const std::string& aUnitOfEnergy);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

double getUnitOfLength(const std::string& aUnitOfLength);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

std::vector<std::vector<float> > computeXRayImage(bool anIntegrateEnergyFlag = true);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

std::vector<std::vector<float> > computeLBuffer(const std::string& aLabel);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

std::vector<std::vector<std::vector<float> > > computeSinogram(

    double x,

    double y,

    double z,

    const std::string& aUnitOfLength,

    unsigned int aNumberOfAngle,

    double anAngleOffset);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

std::vector<std::vector<std::vector<float> > > computeProjectionSet(

    double x,

    double y,

    double z,

    const std::string& aUnitOfLength,

    unsigned int aNumberOfAngle,

    double anAngleOffset);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

std::vector<std::vector<float> > getLastXRayImage();


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

std::vector<std::vector<float> > getLastLBuffer();


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

std::vector<std::vector<std::vector<float> > > getLastSinogram();


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

std::vector<std::vector<std::vector<float> > > getLastProjectionSet();


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

int getImageWidth(const std::vector<std::vector<float> >& anImage);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

int getImageHeght(const std::vector<std::vector<float> >& anImage);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

std::vector<float> getImageRow(const std::vector<std::vector<float> >& anImage,

                               int j);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

std::string getElementName(unsigned short Z);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

std::string getElementSymbol(unsigned short Z);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

unsigned short getElementAtomicNumber(const std::string& anElement);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

double getDensityFromElement(const std::string& anElement);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

double getDensityFromElement(unsigned short Z);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

double getDensityFromHU(double HU);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

double getMassAttenuationFromElement(const std::string& anElement,

        double anEnergy,

        const std::string& aUnitOfEnergy);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

double getMassAttenuationFromElement(unsigned short Z,

        double anEnergy,

        const std::string& aUnitOfEnergy);


//------------------------------------------------------------------------------

double getMassAttenuationFromHU(double HU,

        double anEnergy,

        const std::string& aUnitOfEnergy);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

double getMassAttenuationFromMixture(const std::string& aMixture,

        double anEnergy,

        const std::string& aUnitOfEnergy);


//------------------------------------------------------------------------------


//------------------------------------------------------------------------------

double getMassAttenuationFromCompound(const std::string& aCompound,

        double anEnergy,

        const std::string& aUnitOfEnergy);


double getMuFromHU(double HU,

        double anEnergy,

        const std::string& aUnitOfEnergy);


std::vector<std::vector<std::vector< float> > > convertHU2mu(const std::vector<std::vector<std::vector< float> > >& anImage,

    double anEnergy,

    const std::string& aUnitOfEnergy);


std::vector<float> rayIntersect(const std::string& aLabel,

    double aRayOriginX, double aRayOriginY, double aRayOriginZ,

    double aRayDirectionX, double aRayDirectionY, double aRayDirectionZ);


std::vector<std::vector<float> > loadImage2D(const std::string& aFileName);


std::vector<std::vector<std::vector<float> > > loadImage3D(const std::string& aFileName);


double computeZNCC(const std::vector<std::vector<std::vector<float> > >& aReferenceImage, const std::vector<std::vector<std::vector<float> > >& aTestImage);

double computeRMSE(const std::vector<std::vector<std::vector<float> > >& aReferenceImage, const std::vector<std::vector<std::vector<float> > >& aTestImage);


double getMean(const std::vector<float>& anImage);

double getStddev(const std::vector<float>& anImage);


double computeZNCC(const std::vector<float>& aReferenceImage, const std::vector<float>& aTestImage);

double computeRMSE(const std::vector<float>& aReferenceImage, const std::vector<float>& aTestImage, bool normalise = false);


double computeRMSE(bool normalise = false);

double computeZNCC();

void loadReference(const std::vector<float>& aReferenceImage);

void loadTest(const std::vector<float>& aTestImage);

void lineariseTest(float aThreshold, float aScalingFactor);


float getMinValue(const std::vector<std::vector<std::vector<float> > >& aImage);

float getMaxValue(const std::vector<std::vector<std::vector<float> > >& aImage);


//void FBO2Thrust(unsigned int aFBO, void* aThrustVector, int anOffset = 0);


#endif

clearDetectorEnergyResponse
void clearDetectorEnergyResponse()
Clear the energy response of the detector.

useParallelBeam
void useParallelBeam()
Use a parallel source (e.g. to mimic a source that is extremely far from the scanned object and detec...

setDensity
void setDensity(const std::string &aLabel, double aDensity, const std::string &aUnit)
Set the density corresponding to the material properties of a polygon mesh.

popModelViewMatrix
void popModelViewMatrix()
Restore the matrix from the model/view matrix stack, and remove the last matrix of the stack....

setNodeTransformationMatrix
void setNodeTransformationMatrix(const std::string &aLabel, const std::vector< std::vector< float > > &aMatrix)
Set the transformation matrix of a given node.

saveLastProjectionSet
void saveLastProjectionSet(const std::string &aFileName=std::string(), bool useCompression=true)
Save the last projection set that has been computed.

createOpenGLContext
void createOpenGLContext(int aWindowID=-1, int aRendererMajorVersion=3, int aRendererMinorVersion=2)
Create an OpenGL context (the window won't be shown).

displayNode
void displayNode(const std::string &aLabel)
Display the scenegraph node using OpenGL.

getNodeOnlyBoundingBox
std::vector< double > getNodeOnlyBoundingBox(const std::string &aLabel, const std::string &aUnitOfLength="cm")
Access the bounding box of a given node (without its children). The bounding box is given in the worl...

getOpenGlVersion
std::string getOpenGlVersion()
Accessor on the OpenGL version.

getMajorVersionOfSimpleGVXR
int getMajorVersionOfSimpleGVXR()
Accessor on the major version of SimpleGVXR. This number is changed when incompatible API changes hav...

getMassAttenuationFromElement
double getMassAttenuationFromElement(const std::string &anElement, double anEnergy, const std::string &aUnitOfEnergy)
Accessor on the chemical element's mass attenuation.

addPolygonMeshAsInnerSurface
void addPolygonMeshAsInnerSurface(const std::string &aLabel)
Add a polygon mesh, given its label, to the X-ray renderer as an inner surface.

getSourcePosition
std::vector< double > getSourcePosition(const std::string &aUnitOfLength)
Accessor on the position of the X-ray source.

shearNode
void shearNode(const std::string &aLabel, double yx, double zx, double xy, double zy, double xz, double yz)
Use a shear matrix to transform the node.

setMonoChromatic
void setMonoChromatic(double anEnergy, const std::string &aUnitOfEnergy, double aNumberOfPhotons)
Use a monochromatic beam spectrum (i.e. one single energy).

getElementSymbol
std::string getElementSymbol(unsigned short Z)
Accessor on the chemical element' symbol depending on its Z number.

loadSpectrumFromTSV
void loadSpectrumFromTSV(const std::string &aFileName, const std::string &aUnitOfEnergy, bool aNormalisationFlag)
Load the incident beam energy spectrum from a TSV file.

getLastProjectionSet
std::vector< std::vector< std::vector< float > > > getLastProjectionSet()
Accessor on the last projection set that has been computed.

getChildLabel
std::string getChildLabel(const std::string &aLabel, unsigned int i)
Accessor on the i-th child's label in the list of children of a given node in the scenegraph.

setRootTransformationMatrix
void setRootTransformationMatrix(const std::vector< std::vector< float > > &aMatrix)
Set the transformation matrix of the scengraph's root node.

setWindowBackGroundColour
void setWindowBackGroundColour(float R, float G, float B, int aWindowID=-1)
Set window background colour.

translateNode
void translateNode(const std::string &aLabel, double x, double y, double z, const std::string &aUnitOfLength)
Translate a polygon mesh.

getUnitOfEnergy
double getUnitOfEnergy(const std::string &aUnitOfEnergy)
Accessor on the numerical value corresponding to a unit of energy.

loadMeshFile
void loadMeshFile(const std::string &aLabel, const std::string &aFileName, const std::string &aUnitOfLength, bool addToRendererAsInnerSurface=true)
Load a polygon mesh from a file, set its label in the scenegraph (i.e. identifier) and add it to the ...

getImageWidth
int getImageWidth(const std::vector< std::vector< float > > &anImage)
Accessor on the width of a given image.

saveLastLBuffer
void saveLastLBuffer(const std::string &aFileName=std::string(), bool useCompression=true)
Save the last L-buffer that has been computed.

computeProjectionSet
std::vector< std::vector< std::vector< float > > > computeProjectionSet(double x, double y, double z, const std::string &aUnitOfLength, unsigned int aNumberOfAngle, double anAngleOffset)
Compute the projection set corresponding to the environment that has previously been set,...

startArcBallRotation
void startArcBallRotation(double x, double y)
Call this function when the user starts an arc-ball rotation (e.g. left-mouse button click in the 3-D...

getDetectorSize
std::vector< double > getDetectorSize(const std::string &aUnitOfLength)
Accessor on the size of the X-ray detector.

getAmbientColour
std::vector< float > getAmbientColour(const std::string &aLabel)
Accessor on the ambient colour of the material of a given polygon mesh.

saveLastXRayImage
void saveLastXRayImage(const std::string &aFileName=std::string(), bool useCompression=true)
Save the last X-ray image that has been computed.

getOpenGlRenderer
std::string getOpenGlRenderer()
Accessor on the OpenGL renderer.

getLastXRayImage
std::vector< std::vector< float > > getLastXRayImage()
Accessor on the last X-ray image that has been computed.

destroyWindow
void destroyWindow(int aWindowID=-1)
Close and destroy a given window or OpenGL context.

rotateNode
void rotateNode(const std::string &aLabel, double anAngle, double x, double y, double z)
Rotate a polygon mesh.

getMuFromHU
double getMuFromHU(double HU, double anEnergy, const std::string &aUnitOfEnergy)
Accessor on the HU's linear attenuation coefficient.

getDensity
double getDensity(const std::string &aLabel)
Accessor on the density corresponding to the material properties of a polygon mesh.

getDetectorUpVector
std::vector< double > getDetectorUpVector()
Accessor on the up-vector defining the orientation of the X-ray detector.

hideWindow
void hideWindow(int aWindowID=-1)
Hide a window.

getImageHeght
int getImageHeght(const std::vector< std::vector< float > > &anImage)
Accessor on the height of a given image.

setLinearAttenuationCoefficient
void setLinearAttenuationCoefficient(const std::string &aLabel, double aCoefficient, const std::string &aUnit)
Set the linear attenuation coefficient corresponding to the material properties of a polygon mesh.

rotateModelView
void rotateModelView(double anAngle, double x, double y, double z)
Restore the matrix from the model/view matrix stack, and remove the last matrix of the stack....

getPatchVersionOfSimpleGVXR
int getPatchVersionOfSimpleGVXR()
Accessor on the minor version of SimpleGVXR. This number is changed when bug fixes have been added in...

setWindowSize
void setWindowSize(int aWidth, int aHeight, int aWindowID=-1)
Create an OpenGL context and display it in a window.

translateScene
void translateScene(double x, double y, double z, const std::string &aUnitOfLength)
Translate the 3-D scene (all the polygon meshes will be affected but not modified).

getOversamplingFactor
int getOversamplingFactor()
Accessor on the multiplicative factor to oversample the L-buffers.

getMassAttenuationFromCompound
double getMassAttenuationFromCompound(const std::string &aCompound, double anEnergy, const std::string &aUnitOfEnergy)
Accessor on the compound's mass attenuation.

getEnergyBins
std::vector< double > getEnergyBins(const std::string &aUnitOfEnergy)
Accessor on the energy bins of the beam spectrum.

getPhotonCountEnergyBins
std::vector< double > getPhotonCountEnergyBins()
Accessor on the number of photons per energy bin of the beam spectrum.

getElementName
std::string getElementName(unsigned short Z)
Accessor on the chemical element's name depending on its Z number.

getDetectorRightVector
std::vector< double > getDetectorRightVector()
Accessor on the right-vector defining the orientation of the X-ray detector.

enableArtifactFilteringOnGPU
void enableArtifactFilteringOnGPU(void)
Enable artefact filtering on GPU (it is fast but can be inaccurate).

saveLastCumulatedLBuffer
void saveLastCumulatedLBuffer(const std::string &aFileName=std::string(), bool useCompression=true)
Save the last cumulated L-buffer that has been computed.

makeCube
void makeCube(const std::string &aLabel, double aLength=1.0, const std::string &aUnitOfLength="cm", const std::string &aParent="root")
Create a cube, centred on (0, 0, 0) and set its label in the scenegraph (i.e. identifier)....

setDetectorUpVector
void setDetectorUpVector(double x, double y, double z)
Set the up-vector defining the orientation of the X-ray detector.

getMassAttenuationFromHU
double getMassAttenuationFromHU(double HU, double anEnergy, const std::string &aUnitOfEnergy)
Accessor on the HU's mass attenuation.

getLinearAttenuationCoefficient
double getLinearAttenuationCoefficient(const std::string &aLabel, double anEnergy, const std::string &aUnitOfEnergy)
Accessor on the linear attenuation coefficient at a given energy corresponding to the material proper...

setMassAttenuationCoefficient
void setMassAttenuationCoefficient(const std::string &aLabel, double aCoefficient, const std::string &aUnit)
Set the mass attenuation coefficient corresponding to the material properties of a polygon mesh....

getUnitOfLength
double getUnitOfLength(const std::string &aUnitOfLength)
Accessor on the numerical value corresponding to a unit of length.

getOpenGlVenror
std::string getOpenGlVenror()
Accessor on the OpenGL vendor.

cursorPositionCallback
void cursorPositionCallback(double x, double y, int aViewportWidth, int aViewportHeight)
Call this function when the user moves the mouse.

getTotalEnergyWithDetectorResponse
double getTotalEnergyWithDetectorResponse()
Accessor on a total energy of the beam when the detector response is applied.

getDensityFromElement
double getDensityFromElement(const std::string &anElement)
Accessor on the chemical element's density.

setHU
void setHU(const std::string &aLabel, short HU)
Set the Hounsfield value corresponding to the material properties of a polygon mesh.

setMixture
void setMixture(const std::string &aLabel, const std::string &aMixture)
Set the mixture corresponding to the material properties of a polygon mesh. Don't forget to set the d...

displayScene
void displayScene(bool aSceneRotationFlag=true, int aWindowID=-1)
3-D visualisation of the 3-D scene (source, detector, and scanned objects). Note that there is no int...

addPolygonMeshAsOuterSurface
void addPolygonMeshAsOuterSurface(const std::string &aLabel)
Add a polygon mesh, given its label, to the X-ray renderer as an outer surface.

moveToCentre
void moveToCentre()
Move the scenegraph to the centre.

disableArtifactFiltering
void disableArtifactFiltering(void)
Disable artefact filtering altogether.

createWindow
void createWindow(int aWindowID=-1, int aVisibilityFlag=0, const std::string &aRenderer="OPENGL", int aRendererMajorVersion=3, int aRendererMinorVersion=2)
Create an OpenGL context and display it in a window.

addMesh
void addMesh(const std::string &aDestination, const std::string &aSource)
Add a polygon mesh (aSource) to another one (aDestination). It corresponds to the operation as follow...

setHounsfieldValue
void setHounsfieldValue(const std::string &aLabel, short HU)
Set the Hounsfield value corresponding to the material properties of a polygon mesh.

loadDetectorEnergyResponse
void loadDetectorEnergyResponse(const std::string &aFileName, const std::string &aUnitOfEnergy)
Load the energy response of the detector from a TSV file.

applyCurrentLocalTransformation
void applyCurrentLocalTransformation(const std::string &aLabel)
Apply the current local transformation to all the vertices of a given node in the scenegraph....

setCompound
void setCompound(const std::string &aLabel, const std::string &aCompound)
Set the compound corresponding to the material properties of a polygon mesh. Don't forget to set the ...

makeCylinder
void makeCylinder(const std::string &aLabel, unsigned int aNumberOfSectors=10, double aHeight=1.0, double aRadius=0.5, const std::string &aUnitOfLength="cm", const std::string &aParent="root")
Create a cylinder and set its label in the scenegraph (i.e. identifier). Note that it is not added to...

getMajorVersionOfCoreGVXR
int getMajorVersionOfCoreGVXR()
Accessor on the major version of the core gVirtualXRay library (gvxr). This number is changed when in...

getDiffuseColour
std::vector< float > getDiffuseColour(const std::string &aLabel)
Accessor on the diffuse colour of the material of a given polygon mesh.

invertNormalVectors
void invertNormalVectors(const std::string &aLabel)
Invert the normal vectors of a given polygon mesh.

enableArtifactFilteringOnCPU
void enableArtifactFilteringOnCPU(void)
Enable artefact filtering on CPU (can be extremely slow as it makes use of ray-tracing).

usePointSource
void usePointSource()
Use a point source.

rotateScene
void rotateScene(double anAngle, double x, double y, double z)
Rotate the 3-D scene (all the polygon meshes will be affected but not modified).

rayIntersect
std::vector< float > rayIntersect(const std::string &aLabel, double aRayOriginX, double aRayOriginY, double aRayOriginZ, double aRayDirectionX, double aRayDirectionY, double aRayDirectionZ)

getMinorVersionOfCoreGVXR
int getMinorVersionOfCoreGVXR()
Accessor on the minor version of the core gVirtualXRay library (gvxr). This number is changed when ne...

resetBeamSpectrum
void resetBeamSpectrum()
Set the size of the focal spot of the X-ray generator.

addEnergyBinToSpectrum
void addEnergyBinToSpectrum(double anEnergy, const std::string &aUnitOfEnergy, double aNumberOfPhotons)
Add an energy bin to the beam spectrum (useful to generate polychromatism).

setDetectorNumberOfPixels
void setDetectorNumberOfPixels(int aWidth, int aHeight)
Set the number of pixels of the X-ray detector.

getShininess
float getShininess(const std::string &aLabel)
Accessor on the shininess of the material of a given polygon mesh.

setDetectorPixelSize
void setDetectorPixelSize(double aWidth, double aHeight, const std::string &aUnitOfLength)
Set the pixel size.

setDetectorPosition
void setDetectorPosition(double x, double y, double z, const std::string &aUnitOfLength)
Set the position of the X-ray detector.

disableArtefactFiltering
void disableArtefactFiltering(void)
Disable artefact filtering altogether.

scaleScene
void scaleScene(double x, double y, double z)
Scale the 3-D scene (all the polygon meshes will be affected but not modified).

getMinorVersionOfSimpleGVXR
int getMinorVersionOfSimpleGVXR()
Accessor on the minor version of SimpleGVXR. This number is changed when new functionalities have bee...

moveToCenter
void moveToCenter()
Move the scenegraph to the centre.

setLocalTransformationMatrix
void setLocalTransformationMatrix(const std::string &aLabel, const std::vector< double > &aMatrix)
Set the local transformation matrix of a given node in the scenegraph.

stopArcBallRotation
void stopArcBallRotation()
Call this function when the user stops an arc-ball rotation (e.g. release the left-mouse button click...

subtractMesh
void subtractMesh(const std::string &aDestination, const std::string &aSource)
Subtract a polygon mesh (aSource) from another one (aDestination). It corresponds to the operation as...

getMaterialLabel
std::string getMaterialLabel(const std::string &aLabel)
Accessor on the material label of a polygon mesh.

getNodeWorldTransformationMatrix
std::vector< std::vector< float > > getNodeWorldTransformationMatrix(const std::string &aLabel)
Accessor on the transformation matrix of a given node.

setColour
void setColour(const std::string &aLabel, float R, float G, float B, float A)
Set the colour of a given polygon mesh.

setMu
void setMu(const std::string &aLabel, double aCoefficient, const std::string &aUnit)
Set the linear attenuation coefficient corresponding to the material properties of a polygon mesh.

setSceneTransformationMatrix
void setSceneTransformationMatrix(const std::vector< std::vector< float > > &aMatrix)
Set the 3-D scene transformation matrix.

lookAt
void lookAt(double eyeX, double eyeY, double eyeZ, double lookAtX, double lookAtY, double lookAtZ, double upX, double upY, double upZ)
Replace the modelling-viewing matrix by a viewing transformation matrix. It behaves as the old gluLoo...

getVersionOfSimpleGVXR
std::string getVersionOfSimpleGVXR()
Accessor on the full string version of SimpleGVXR.

getSpecularColour
std::vector< float > getSpecularColour(const std::string &aLabel)
Accessor on the specular colour of the material of a given polygon mesh.

getVersionOfCoreGVXR
std::string getVersionOfCoreGVXR()
Accessor on the full string version of the core gVirtualXRay library (gvxr).

getSceneTransformationMatrix
std::vector< std::vector< float > > getSceneTransformationMatrix()
Accessor on the 3-D scene transformation matrix.

setHounsfieldUnit
void setHounsfieldUnit(const std::string &aLabel, short HU)
Set the Hounsfield value corresponding to the material properties of a polygon mesh.

getLatestScreenshot
const std::vector< std::vector< std::vector< float > > > & getLatestScreenshot()
Get the latest screenshot.

getNodeAndChildrenBoundingBox
std::vector< double > getNodeAndChildrenBoundingBox(const std::string &aLabel, const std::string &aUnitOfLength="cm")
Access the bounding box of a given node and all its children (if any). The bounding box is given in t...

getNodeLocalTransformationMatrix
std::vector< std::vector< float > > getNodeLocalTransformationMatrix(const std::string &aLabel)
Accessor on the transformation matrix of a given node.

saveSTLfile
void saveSTLfile(const std::string &aLabel, const std::string &aFileName=std::string())
Save the polygon mesh of a given node.

removePolygonMeshesFromXRayRenderer
void removePolygonMeshesFromXRayRenderer()
Empty the X-ray renderer from all its meshes. Note that the meshes are kept in the scenegraph.

getRootTransformationMatrix
std::vector< std::vector< float > > getRootTransformationMatrix()
Accessor on the transformation matrix of the scengraph's root node.

saveLastSinogram
void saveLastSinogram(const std::string &aFileName=std::string(), bool useCompression=true)
Save the last sinogram that has been computed.

getLastSinogram
std::vector< std::vector< std::vector< float > > > getLastSinogram()
Accessor on the last sinogram that has been computed.

setSourcePosition
void setSourcePosition(double x, double y, double z, const std::string &aUnitOfLength)
Set the position of the X-ray source.

getNumberOfChildren
unsigned int getNumberOfChildren(const std::string &aLabel)
Get the number of children of a node in the scenegraph.

getMassAttenuationCoefficient
double getMassAttenuationCoefficient(const std::string &aLabel, double anEnergy, const std::string &aUnitOfEnergy)
Accessor on the mass attenuation coefficient at a given energy corresponding to the material properti...

destroyAllWindows
void destroyAllWindows(void)
Close and destroy all the windows and OpenGL contexts that have been created.

enableArtefactFilteringOnGPU
void enableArtefactFilteringOnGPU(void)
Enable artefact filtering on GPU (it is fast but can be inaccurate).

autoCreateOpenGLContext
void autoCreateOpenGLContext(bool aFlag=true)
Create an OpenGL context automatically.

orthographic
void orthographic(double left, double right, double bottom, double top, double zNear, double zFar)
Replace the projection matrix by a orthographic projection matrix. It behaves as the old glOrtho func...

getDensityFromHU
double getDensityFromHU(double HU)
Accessor on the HU's density.

getLastLBuffer
std::vector< std::vector< float > > getLastLBuffer()
Accessor on the last L-buffer that has been computed.

computeSinogram
std::vector< std::vector< std::vector< float > > > computeSinogram(double x, double y, double z, const std::string &aUnitOfLength, unsigned int aNumberOfAngle, double anAngleOffset)
Compute the sinogram corresponding to the environment that has previously been set,...

loadSceneGraph
void loadSceneGraph(const std::string &aFileName, const std::string &aUnitOfLength)
Load a scenegraph from a file and add its polygon meshes to the X-ray renderer.

renderLoop
void renderLoop(int aWindowID=-1)
3-D visualisation of the 3-D scene (source, detector, and scanned objects). Note that there is intera...

takeScreenshot
const std::vector< std::vector< std::vector< float > > > & takeScreenshot(int aWindowID=-1)
Take screenshot.

showWindow
void showWindow(int aWindowID=-1)
Make an OpenGL context visible and display a window.

getDetectorPosition
std::vector< double > getDetectorPosition(const std::string &aUnitOfLength)
Accessor on the position of the X-ray detector.

getElementAtomicNumber
unsigned short getElementAtomicNumber(const std::string &anElement)
Accessor on the chemical element's Z number.

makeIsoSurface
void makeIsoSurface(const std::string &aLabel, short anIsoValue, const std::vector< short > &aVoxelDataSet, unsigned int aWidth, unsigned int aHeight, unsigned int aDepth, double aSpacingX, double aSpacingY, double aSpacingZ, const std::string &aUnitOfLength="cm", const std::string &aParent="root")
Create an iso-surface from a 3D image and set its label in the scenegraph (i.e. identifier)....

getMassAttenuationFromMixture
double getMassAttenuationFromMixture(const std::string &aMixture, double anEnergy, const std::string &aUnitOfEnergy)
Accessor on the mixture's mass attenuation.

setWindowBackGroundColor
void setWindowBackGroundColor(float R, float G, float B, int aWindowID=-1)
Set window background colour.

getNumberOfPrimitives
unsigned int getNumberOfPrimitives(const std::string &aLabel)
Accessor on the number of primitives of a given node.

computeLBuffer
std::vector< std::vector< float > > computeLBuffer(const std::string &aLabel)
Compute the L-buffer of a polygon mesh corresponding to the environment that has previously been set,...

getImageRow
std::vector< float > getImageRow(const std::vector< std::vector< float > > &anImage, int j)
Accessor on the j-th row of pixels of a given image.

perspective
void perspective(double fovy, double aspect, double zNear, double zFar)
Replace the projection matrix by a perspective projection matrix. It behaves as the old gluPerspectiv...

scrollCallback
void scrollCallback(double xoffset, double yoffset)
Call this function when the user scrolls.

getPatchVersionOfCoreGVXR
int getPatchVersionOfCoreGVXR()
Accessor on the minor version of the core gVirtualXRay library (gvxr). This number is changed when bu...

emptyMesh
void emptyMesh(const std::string &aLabel, const std::string &aParent="root")
Create an empty polygon mesh and set its label in the scenegraph (i.e. identifier)....

computeXRayImage
std::vector< std::vector< float > > computeXRayImage(bool anIntegrateEnergyFlag=true)
Compute the X-ray projection corresponding to the environment that has previously been set,...

resetSceneTransformation
void resetSceneTransformation()
Replace the 3-D transformation matrix of the overall 3-D scene by an identity matrix.

enableArtefactFilteringOnCPU
void enableArtefactFilteringOnCPU(void)
Enable artefact filtering on CPU (can be extremely slow as it makes use of ray-tracing).

setColor
void setColor(const std::string &aLabel, float R, float G, float B, float A)
Set the color of a given polygon mesh.

useParallelSource
void useParallelSource()
Use a parallel source (e.g. to mimic a source that is extremely far from the scanned object and detec...

setOversamplingFactor
void setOversamplingFactor(int aFactor=1)
Set the multiplicative factor to oversample the L-buffers.

scaleNode
void scaleNode(const std::string &aLabel, double x, double y, double z)
Scale a polygon mesh.

removePolygonMeshesFromSceneGraph
void removePolygonMeshesFromSceneGraph()
Empty the scenegraph. Note that it also empties the X-ray renderer from all its meshes.

pushModelViewMatrix
void pushModelViewMatrix()
Add the current matrix to the model/view matrix stack. It behaves as the combination of the old glMat...

usingArcBallRotation
bool usingArcBallRotation()
Check if arc-ball rotation is currently in use.

getLocalTransformationMatrix
std::vector< double > getLocalTransformationMatrix(const std::string &aLabel)
Accessor on the local transformation matrix of a given node in the scenegraph. If the node does not e...

getDetectorNumberOfPixels
std::vector< int > getDetectorNumberOfPixels()
Accessor on the number of pixels of the X-ray detector.

setElement
void setElement(const std::string &aLabel, unsigned short Z)
Set the chemical element (or element) corresponding to the material properties of a polygon mesh.