Eigene Dateien/Vis/src/VTransferFunction2D.cpp

Go to the documentation of this file.

#include "VTransferFunction2D.h"
#include "glew.h"
#include <algorithm>
#include "QVolRendCanvas.h"

VTransferFunction2D::~VTransferFunction2D()
{
        if(m_VolumeHistogramDisplayList2D != 0)
        {
                glDeleteLists(m_VolumeHistogramDisplayList2D, 1);
        }
        
        if(m_VolumeHistogram2D)
        {
                m_VolumeHistogram2D = 0;
        }

        if(m_MainCanvas)
        {
                m_MainCanvas = NULL;
        }

        
}

void VTransferFunction2D::reinit()
{
        /*vTransferFunction2DPoint p1;
        p1.m_Color = VVector(0.0f, 0.0f, 0.0f);
        p1.m_Alpha = 0.0f;
        p1.m_density = 0.0f;
        p1.m_gmag = 0.0f;

        vTransferFunction2DPoint p2;
        p2.m_Color = VVector(1.0f, 1.0f, 1.0f);
        p2.m_Alpha = 1.0f;
        p1.m_density = 1.0f;
        p2.m_gmag = 0.0f;

        vTransferFunction2DPoint p3;
        p3.m_Color = VVector(1.0f, 1.0f, 1.0f);
        p3.m_Alpha = 1.0f;
        p3.m_gmag = 1.0f;
        p3.m_density = 1.0f;

        vTransferFunction2DPoint p4;
        p4.m_Color = VVector(1.0f, 1.0f, 1.0f);
        p4.m_Alpha = 1.0f;
        p4.m_gmag = 1.0f;
        p4.m_density = 0.0f;

        vTransferFunction2DPoint p5;
        p5.m_Color = VVector(0.5f, 0.5f, 0.5f);
        p5.m_Alpha = 0.5f;
        p5.m_gmag = 0.5f;
        p5.m_density = 0.5f;

        m_FuncControlPoints.push_back(p5);

        vTransferFunctionTriangle t1(p1,p2,p3);
        vTransferFunctionTriangle t2(p5,p2,p3);
        vTransferFunctionTriangle t3(p5,p3,p4);
        vTransferFunctionTriangle t4(p5,p4,p1);

        m_FuncControlTriangles.push_back(t1);
        m_FuncControlTriangles.push_back(t2);
        m_FuncControlTriangles.push_back(t3);
        m_FuncControlTriangles.push_back(t4);*/
}


void VTransferFunction2D::draw2d()
{
        if(m_VolumeHistogramDisplayList2D != 0)
        {
                glCallList(m_VolumeHistogramDisplayList2D);
        }

        glEnable(GL_TEXTURE_2D);
        glDisable(GL_TEXTURE_2D);

        glPointSize(7.0f);
        glBegin(GL_POINTS);
        //draw all points
        for(int i = 0; i < (int)m_FuncControlPoints.size(); i++)
        {               
                vTransferFunction2DPoint ptmp = m_FuncControlPoints[i];
                
                glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
                glVertex3f(ptmp.m_density * 2.0f - 1.0f, ptmp.m_gmag * 2.0f - 1.0f, -0.15f);
        }
        glEnd();

        glPointSize(5.0f);
        glBegin(GL_POINTS);
        //draw all points
        for(int i = 0; i < (int)m_FuncControlPoints.size(); i++)
        {               
                vTransferFunction2DPoint ptmp = m_FuncControlPoints[i];
                
                glColor4f(ptmp.m_Color.getX(), ptmp.m_Color.getY(), ptmp.m_Color.getZ(), 1.0f);
                glVertex3f(ptmp.m_density * 2.0f - 1.0f, ptmp.m_gmag * 2.0f - 1.0f, -0.2f);
        }
        glEnd();

        glLineWidth(1.0f);
        glBegin(GL_LINES);
        for (int i = 0; i < (int)m_FuncControlTriangles.size(); i++)
        {
                vTransferFunctionWannabeTriangle t;
                t = m_FuncControlTriangles[i];

                glColor3f(1.0f, 1.0f, 1.0f);
                glVertex3f( t.point1.x, t.point1.y , -0.02f-i*0.01f);
                glVertex3f( t.point2.x, t.point2.y , -0.02f-i*0.01f);

                glVertex3f( t.point2.x, t.point2.y , -0.02f-i*0.01f);
                glVertex3f( t.point4.x, t.point4.y , -0.02f-i*0.01f);

                glVertex3f( t.point4.x, t.point4.y , -0.02f-i*0.01f);
                glVertex3f( t.point1.x, t.point1.y , -0.02f-i*0.01f);
        }
        glEnd();

        glEnable(GL_BLEND);
        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

        glBegin(GL_QUADS);
        for (int i = 0; i < (int)m_FuncControlTriangles.size(); i++)
        {
                vTransferFunctionWannabeTriangle t;
                t = m_FuncControlTriangles[i];

                float rgba[4];
                rgba[0] = t.point1.rgb.getX();
                rgba[1] = t.point1.rgb.getY();
                rgba[2] = t.point1.rgb.getZ();
                rgba[3] = t.point1.alpha*0.7f;
                glColor4fv(rgba);
                glVertex3f( t.point1.x, t.point1.y , -0.02f-i*0.01f);

                rgba[0] = t.point2.rgb.getX();
                rgba[1] = t.point2.rgb.getY();
                rgba[2] = t.point2.rgb.getZ();
                rgba[3] = t.point2.alpha*0.7f;
                glColor4fv(rgba);
                glVertex3f( t.point2.x, t.point2.y , -0.02f-i*0.01f);

                rgba[0] = t.point3.rgb.getX();
                rgba[1] = t.point3.rgb.getY();
                rgba[2] = t.point3.rgb.getZ();
                rgba[3] = t.point3.alpha*0.7f;
                glColor4fv(rgba);
                glVertex3f( t.point3.x, t.point3.y , -0.02f-i*0.01f);

                rgba[0] = t.point4.rgb.getX();
                rgba[1] = t.point4.rgb.getY();
                rgba[2] = t.point4.rgb.getZ();
                rgba[3] = t.point4.alpha*0.7f;
                glColor4fv(rgba);
                glVertex3f( t.point4.x, t.point4.y , -0.02f-i*0.01f);
        }
        glEnd();

        glDisable(GL_BLEND);
}

void VTransferFunction2D::addTransferFunctionPoint( vTransferFunction2DPoint newPoint )
{
        m_FuncControlPoints.push_back(newPoint);

        vTransferFunctionWannabeTriangle t;
        //bottom point
        t.point1.x              = newPoint.m_density * 2.0f - 1.0f;
        t.point1.y              = (newPoint.m_gmag - 0.3f) * 2.0f - 1.0f;
        t.point1.rgb    = newPoint.m_Color;
        t.point1.alpha  = 0.0f,//newPoint.m_Alpha;

        //right point
        t.point2.x              = (newPoint.m_density + 0.05f) * 2.0f - 1.0f;
        t.point2.y              = (newPoint.m_gmag + 0.15f) * 2.0f - 1.0f;
        t.point2.rgb    = VVector(0.0f,0.0f,0.0f);
        t.point2.alpha  = 0.0f;

        //left point
        t.point4.x              = (newPoint.m_density - 0.05f) * 2.0f - 1.0f;
        t.point4.y              = (newPoint.m_gmag + 0.15f) * 2.0f - 1.0f;
        t.point4.rgb    = VVector(0.0f,0.0f,0.0f);
        t.point4.alpha  = 0.0f;

        //wannabe point on the line p2-p4
        t.point3.x              = (newPoint.m_density ) * 2.0f - 1.0f;
        t.point3.y              = (newPoint.m_gmag + 0.15f) * 2.0f - 1.0f;
        t.point3.rgb    = newPoint.m_Color;
        t.point3.alpha  = newPoint.m_Alpha;

        //p1 p2 p3 is ccw

        m_FuncControlTriangles.push_back(t);
        m_hasChanged = true;

}

VVector VTransferFunction2D::transferFunctionPointInRange(float selectedDensity, float gmag, float range)
{

        return VVector(0.0f,0.0f,-1.0f);
}

void VTransferFunction2D::addTransferFunctionPoint(vTransferFunctionWannabeTriangle t, vTransferFunction2DPoint newPoint)
{
        m_FuncControlPoints.push_back(newPoint);
        m_FuncControlTriangles.push_back(t);
        m_hasChanged = true;
}

void VTransferFunction2D::removeTransferFunctionPoint(float density, float gmag, float tres)
{
        std::vector<vTransferFunction2DPoint> _FuncControlPoints;
        std::vector<vTransferFunctionWannabeTriangle> _FuncControlTriangles;

        for(int i = 0; i< (int)m_FuncControlPoints.size(); i++)
        {
                if(abs(m_FuncControlPoints[i].m_density - density) > tres || abs(m_FuncControlPoints[i].m_gmag - gmag) > tres)
                {
                        _FuncControlPoints.push_back(m_FuncControlPoints[i]);
                        _FuncControlTriangles.push_back(m_FuncControlTriangles[i]);
                }
        }

        m_FuncControlPoints.clear();
        m_FuncControlTriangles.clear();
        m_FuncControlPoints = _FuncControlPoints;
        m_FuncControlTriangles = _FuncControlTriangles;

        _FuncControlTriangles.clear();
        _FuncControlPoints.clear();
        m_hasChanged = true;
        
}

void VTransferFunction2D::changePointColor(float density, float gmag, VVector color, float alpha, float tres)
{
        
        for(int index = 0; index< (int)m_FuncControlPoints.size(); index++)
        {
                if(abs(m_FuncControlPoints[index].m_density - density) < tres && abs(m_FuncControlPoints[index].m_gmag - gmag) < tres)
                {
                
                        m_FuncControlPoints[index].m_Color = color;
                        m_FuncControlPoints[index].m_Alpha = alpha;

                        m_FuncControlTriangles[index].point1.rgb        = m_FuncControlPoints[index].m_Color;
                        m_FuncControlTriangles[index].point1.alpha      = 0.0f;//m_FuncControlPoints[index].m_Alpha;

                        m_FuncControlTriangles[index].point2.rgb        = VVector(0.0f,0.0f,0.0f);
                        m_FuncControlTriangles[index].point2.alpha      = 0.0f;

                        m_FuncControlTriangles[index].point4.rgb        = VVector(0.0f,0.0f,0.0f);
                        m_FuncControlTriangles[index].point4.alpha      = 0.0f;

                        m_FuncControlTriangles[index].point3.rgb        = m_FuncControlPoints[index].m_Color;
                        m_FuncControlTriangles[index].point3.alpha      = m_FuncControlPoints[index].m_Alpha;
                        break;
                }
        }

        m_hasChanged = true;
}

void VTransferFunction2D::changeTriangleSize( int index, float offsetw, float offseth)
{
        
        //if( m_FuncControlTriangles[index].point3.y - m_FuncControlTriangles[index].point1.y + offseth > 0.025f)
        {
                m_FuncControlTriangles[index].point1.y -= 2.0f * offseth/3.0f;
                m_FuncControlTriangles[index].point2.y += offseth/3.0f;
                m_FuncControlTriangles[index].point3.y += offseth/3.0f;
                m_FuncControlTriangles[index].point4.y += offseth/3.0f;

                m_FuncControlTriangles[index].a_offseth += offseth;
        }

        if( m_FuncControlTriangles[index].point2.x - m_FuncControlTriangles[index].point4.x + offsetw > 0.025f)
        {
                m_FuncControlTriangles[index].point1.x -= 0.0f;
                m_FuncControlTriangles[index].point2.x += offsetw/2.0f;
                m_FuncControlTriangles[index].point3.x += 0.0f;
                m_FuncControlTriangles[index].point4.x -= offsetw/2.0f;

                m_FuncControlTriangles[index].a_offsetw += offsetw;
        }
        
        m_hasChanged = true;
}

void VTransferFunction2D::changeTriangleSkew( int index, float skew )
{
        
        if( abs(m_FuncControlTriangles[index].a_skew + skew) < 0.1f)
        {
                m_FuncControlTriangles[index].point1.x += skew;

                m_FuncControlTriangles[index].a_skew += skew;
        }
        
        m_hasChanged = true;
}

int VTransferFunction2D::findIndexTransferFunctionPoint(float density, float gmag, float tres)
{
        int index = -1;

        for(int i = 0; i< (int)m_FuncControlPoints.size(); i++)
        {
                if(abs(m_FuncControlPoints[i].m_density - density) < tres && abs(m_FuncControlPoints[i].m_gmag - gmag) < tres)
                {
                        index = i;
                        break;
                }
        }

        return index;
        
}

void VTransferFunction2D::changePointPosition(int index, float newx, float newy)
{

        //assert
        if( index < 0 || index >= (int)m_FuncControlPoints.size()) return;

        m_FuncControlPoints[index].m_density = newx*0.5f + 0.5f;

        if(m_FuncControlPoints[index].m_density > 1.0f) m_FuncControlPoints[index].m_density = 1.0f;
        if(m_FuncControlPoints[index].m_density < 0.0f) m_FuncControlPoints[index].m_density = 0.0f;

        m_FuncControlPoints[index].m_gmag = newy*0.5f + 0.5f;
        if(m_FuncControlPoints[index].m_gmag > 1.0f) m_FuncControlPoints[index].m_gmag = 1.0f;
        if(m_FuncControlPoints[index].m_gmag < 0.0f) m_FuncControlPoints[index].m_gmag = 0.0f;

        m_FuncControlTriangles[index].point1.x          = m_FuncControlPoints[index].m_density * 2.0f - 1.0f + m_FuncControlTriangles[index].a_skew;
        m_FuncControlTriangles[index].point1.y          = (m_FuncControlPoints[index].m_gmag - 0.3f) * 2.0f - 1.0f  - 2.0f * m_FuncControlTriangles[index].a_offseth / 3.0f;

        //right point
        m_FuncControlTriangles[index].point2.x          = (m_FuncControlPoints[index].m_density + 0.05f) * 2.0f - 1.0f + m_FuncControlTriangles[index].a_offsetw / 2.0f;
        m_FuncControlTriangles[index].point2.y          = (m_FuncControlPoints[index].m_gmag + 0.15f) * 2.0f - 1.0f + m_FuncControlTriangles[index].a_offseth / 3.0f;

        //left point
        m_FuncControlTriangles[index].point4.x          = (m_FuncControlPoints[index].m_density - 0.05f) * 2.0f - 1.0f - + m_FuncControlTriangles[index].a_offsetw / 2.0f;
        m_FuncControlTriangles[index].point4.y          = (m_FuncControlPoints[index].m_gmag + 0.15f) * 2.0f - 1.0f + m_FuncControlTriangles[index].a_offseth / 3.0f;

        //wannabe point on the line p2-p4
        m_FuncControlTriangles[index].point3.x          = (m_FuncControlPoints[index].m_density ) * 2.0f - 1.0f;
        m_FuncControlTriangles[index].point3.y          = (m_FuncControlPoints[index].m_gmag + 0.15f) * 2.0f - 1.0f + m_FuncControlTriangles[index].a_offseth / 3.0f;

        m_hasChanged = true;
}


void VTransferFunction2D::setHistogram2D(unsigned char * volumeHistogram2d)
{
        this->clear();
        m_VolumeHistogram2D = volumeHistogram2d;

        glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

        glGenTextures(1, &m_Histogram2DTextureHandle);

        glActiveTexture(GL_TEXTURE0);
        glBindTexture(GL_TEXTURE_2D,m_Histogram2DTextureHandle);

        glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_CLAMP);
        glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_CLAMP);
        glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);

        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1024, 1024, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
        
        glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0,1024, 1024, GL_RGBA, GL_UNSIGNED_BYTE, &(m_VolumeHistogram2D[0]));

        glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);

        generateDisplayList2D();

        reinit();
}

void VTransferFunction2D::generateDisplayList2D()
{
        if(m_VolumeHistogramDisplayList2D != 0)
        {
                glDeleteLists(m_VolumeHistogramDisplayList2D, 1);
        }
        
        m_VolumeHistogramDisplayList2D = glGenLists(1);
        glNewList(m_VolumeHistogramDisplayList2D, GL_COMPILE);

        glEnable(GL_TEXTURE_2D);

        glBegin(GL_QUADS);

                //glColor4f(0.0f,0.0f,0.0f,1.0f);

                glTexCoord2f(0.0f, 0.0f);glVertex3f(-1.0f, -1.0f, 0.0f);
                glTexCoord2f(1.0f, 0.0f);glVertex3f( 1.0f, -1.0f, 0.0f);
                glTexCoord2f(1.0f, 1.0f);glVertex3f( 1.0f,  1.0f, 0.0f);
                glTexCoord2f(0.0f, 1.0f);glVertex3f(-1.0f,  1.0f, 0.0f);
                 
        glEnd();

        glDisable(GL_TEXTURE_2D);

        glEndList();

}

void VTransferFunction2D::interpolateTransferTriangles()
{
        if(!m_FramebufferObject)
        {
                m_FramebufferObject = new VFramebufferObject(1024,1024,GL_RGBA);
        }

        glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
        if(m_FramebufferObject->getFboHandle() == 0)
        {
                m_FramebufferObject->init();
        }
        m_FramebufferObject->bind();

        //glEnable(GL_BLEND);
        //glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

        glBegin(GL_QUADS);
        for (int i = 0; i < (int)m_FuncControlTriangles.size(); i++)
        {
                vTransferFunctionWannabeTriangle t;
                t = m_FuncControlTriangles[i];

                float rgba[4];
                rgba[0] = t.point1.rgb.getX();
                rgba[1] = t.point1.rgb.getY();
                rgba[2] = t.point1.rgb.getZ();
                rgba[3] = t.point1.alpha;
                glColor4fv(rgba);
                glVertex3f( t.point1.x, t.point1.y , -0.02f-i*0.01f);

                rgba[0] = t.point2.rgb.getX();
                rgba[1] = t.point2.rgb.getY();
                rgba[2] = t.point2.rgb.getZ();
                rgba[3] = t.point2.alpha;
                glColor4fv(rgba);
                glVertex3f( t.point2.x, t.point2.y , -0.02f-i*0.01f);

                rgba[0] = t.point3.rgb.getX();
                rgba[1] = t.point3.rgb.getY();
                rgba[2] = t.point3.rgb.getZ();
                rgba[3] = t.point3.alpha;
                glColor4fv(rgba);
                glVertex3f( t.point3.x, t.point3.y , -0.02f-i*0.01f);

                rgba[0] = t.point4.rgb.getX();
                rgba[1] = t.point4.rgb.getY();
                rgba[2] = t.point4.rgb.getZ();
                rgba[3] = t.point4.alpha;
                glColor4fv(rgba);
                glVertex3f( t.point4.x, t.point4.y , -0.02f-i*0.01f);
        }
        glEnd();

        //glDisable(GL_BLEND);
        m_FramebufferObject->unbind();

        //m_FramebufferObject->saveImage("./2dHist.tga");

        m_hasChanged = false;
        
}

bool VTransferFunction2D::load(std::string filepath)
{
        if(filepath == "")
        {
                return true;
        }
        FILE *fp = NULL;

        fopen_s(&fp,filepath.c_str(),"rb");

        if(!fp)
        {
                return false;
        }
        unsigned int numPoints;

        fread(&numPoints,sizeof(unsigned int),1,fp);

        m_FuncControlPoints.clear();
        m_FuncControlTriangles.clear();
        for(unsigned int i = 0; i < numPoints; ++i)
        {
                vTransferFunction2DPoint tmpp;
                vTransferFunctionWannabeTriangle tmpt;

                float pValues[6];
                fread(pValues, sizeof(float), 6, fp);
                tmpp.m_Color.setX(pValues[0]); 
                tmpp.m_Color.setY(pValues[1]); 
                tmpp.m_Color.setZ(pValues[2]); 
                tmpp.m_Alpha = pValues[3]; 
                tmpp.m_gmag = pValues[4];
                tmpp.m_density = pValues[5]; 

                

                float p1Values[6];
                fread(p1Values, sizeof(float), 6, fp);

                tmpt.point1.x = p1Values[0]; 
                tmpt.point1.y = p1Values[1];
                tmpt.point1.rgb.setX(p1Values[2]); 
                tmpt.point1.rgb.setY(p1Values[3]); 
                tmpt.point1.rgb.setZ(p1Values[4]); 
                tmpt.point1.alpha = p1Values[5];
                
                float p2Values[6];
                fread(p2Values, sizeof(float), 6, fp);
                tmpt.point2.x = p2Values[0];
                tmpt.point2.y = p2Values[1]; 
                tmpt.point2.rgb.setX(p2Values[2]); 
                tmpt.point2.rgb.setY(p2Values[3]); 
                tmpt.point2.rgb.setZ(p2Values[4]); 
                tmpt.point2.alpha = p2Values[5]; 
                

                float p3Values[6];
                fread(p3Values, sizeof(float), 6, fp);
                tmpt.point3.x = p3Values[0]; 
                tmpt.point3.y = p3Values[1]; 
                tmpt.point3.rgb.setX(p3Values[2]); 
                tmpt.point3.rgb.setY(p3Values[3]); 
                tmpt.point3.rgb.setZ(p3Values[4]); 
                tmpt.point3.alpha = p3Values[5];
                

                float p4Values[6];
                fread(p4Values, sizeof(float), 6, fp);
                tmpt.point4.x = p4Values[0];
                tmpt.point4.y = p4Values[1]; 
                tmpt.point4.rgb.setX(p4Values[2]); 
                tmpt.point4.rgb.setY(p4Values[3]); 
                tmpt.point4.rgb.setZ(p4Values[4]); 
                tmpt.point4.alpha = p4Values[5]; 
                

                float addVals[3];
                fread(addVals, sizeof(float), 3, fp);
                tmpt.a_offsetw = addVals[0]; 
                tmpt.a_offseth = addVals[1]; 
                tmpt.a_skew = addVals[2]; 

                m_FuncControlPoints.push_back(tmpp);
                m_FuncControlTriangles.push_back(tmpt); 
        }
        fclose(fp);
        m_hasChanged = true;
        return true;
}

bool VTransferFunction2D::save(std::string filepath)
{
        if(filepath == "")
        {
                return true;
        }
        FILE *fp = NULL;



        fopen_s(&fp,filepath.c_str(),"wb");

        if(!fp)
        {
                return false;
        }
        unsigned int numPoints = (unsigned int)m_FuncControlPoints.size();

        fwrite(reinterpret_cast<char*>(&numPoints), sizeof(unsigned int), 1,fp);

        for(int i = 0; i < (int)m_FuncControlPoints.size(); ++i)
        {
                vTransferFunction2DPoint tmpp = m_FuncControlPoints[i];
                vTransferFunctionWannabeTriangle tmpt = m_FuncControlTriangles[i];

                float pValues[6];
                pValues[0] = tmpp.m_Color.getX();
                pValues[1] = tmpp.m_Color.getY();
                pValues[2] = tmpp.m_Color.getZ();
                pValues[3] = tmpp.m_Alpha;
                pValues[4] = tmpp.m_gmag;
                pValues[5] = tmpp.m_density;

                fwrite(reinterpret_cast<char*>(pValues), sizeof(float), 6, fp);
                
                float p1Values[6];
                p1Values[0] = tmpt.point1.x;
                p1Values[1] = tmpt.point1.y;
                p1Values[2] = tmpt.point1.rgb.getX();
                p1Values[3] = tmpt.point1.rgb.getY();
                p1Values[4] = tmpt.point1.rgb.getZ();
                p1Values[5] = tmpt.point1.alpha;
                fwrite(reinterpret_cast<char*>(p1Values), sizeof(float), 6, fp);

                float p2Values[6];
                p2Values[0] = tmpt.point2.x;
                p2Values[1] = tmpt.point2.y;
                p2Values[2] = tmpt.point2.rgb.getX();
                p2Values[3] = tmpt.point2.rgb.getY();
                p2Values[4] = tmpt.point2.rgb.getZ();
                p2Values[5] = tmpt.point2.alpha;
                fwrite(reinterpret_cast<char*>(p2Values), sizeof(float), 6, fp);

                float p3Values[6];
                p3Values[0] = tmpt.point3.x;
                p3Values[1] = tmpt.point3.y;
                p3Values[2] = tmpt.point3.rgb.getX();
                p3Values[3] = tmpt.point3.rgb.getY();
                p3Values[4] = tmpt.point3.rgb.getZ();
                p3Values[5] = tmpt.point3.alpha;
                fwrite(reinterpret_cast<char*>(p3Values), sizeof(float), 6, fp);

                float p4Values[6];
                p4Values[0] = tmpt.point4.x;
                p4Values[1] = tmpt.point4.y;
                p4Values[2] = tmpt.point4.rgb.getX();
                p4Values[3] = tmpt.point4.rgb.getY();
                p4Values[4] = tmpt.point4.rgb.getZ();
                p4Values[5] = tmpt.point4.alpha;
                fwrite(reinterpret_cast<char*>(p4Values), sizeof(float), 6, fp);

                float addVals[3];
                addVals[0] = tmpt.a_offsetw;
                addVals[1] = tmpt.a_offseth;
                addVals[2] = tmpt.a_skew;

                fwrite(reinterpret_cast<char*>(addVals), sizeof(float), 3, fp);

        }

        fclose(fp);
        return true;
}

---