Changeset 410

Timestamp:

Aug 13, 2012, 8:36:29 PM (12 years ago)

Author:

Torben Dannhauer

Message:

New Distortion setup strategy added: distortionNG can now handle configuration files of "Projection Designer"

Location:

experimental/distortionNG

Files:

• DistortionSetupStrategyProjectSyntropy.cpp (modified) (3 diffs)
• DistortionSetupStrategyProjectionDesigner.cpp (modified) (2 diffs)
• DistortionSetupStrategyProjectionDesigner.h (modified) (2 diffs)
• main.cpp (modified) (3 diffs)
• resources/ProjectionDesigner (added)
• resources/ProjectionDesigner/example1 (added)
• resources/ProjectionDesigner/example1/blend_center.bmp (added)
• resources/ProjectionDesigner/example1/distort_center.bmp (added)
• resources/ProjectionDesigner/example1/view_center.cfg (added)

experimental/distortionNG/DistortionSetupStrategyProjectSyntropy.cpp

@@ -19 +19 @@
 #include <osg/Vec3d>
 #include <osg/ImageUtils>
+#include <osgDB/FileUtils>
 #include <osgDB/ReadFile>
 #include <osgDB/fstream>
@@ -235 +236 @@
         }
 
+        if(     !osgDB::fileExists(_blendmapFilename) || !osgDB::fileExists(_frustumFilename) || !osgDB::fileExists(_distortionFilename) )
+        {
+                OSG_ALWAYS<<"DistortionSetupStrategyProjectionDesigner::delegateDistortionSetup : One of the specified input files does not exist!"<<std::endl;
+                return;
+        }
+
         //OSG_ALWAYS<<"drin"<<std::endl;
 
@@ -303 +310 @@
                 
                 //Frustum Parameters: Left, Right, Bottom, Top, zNear, zFar.
-                // Important: By definition of OpenGL, Left, Right, Bottom and Top must be set as tangens!
-                projectionOffset.makeFrustum(frustumValues[10], frustumValues[11], frustumValues[12], frustumValues[13], zNear, zFar);
+                // Important: By definition of OpenGL, Left, Right, Bottom and Top must be set as tangens, multiplied by zNear!
+                projectionOffset.makeFrustum(frustumValues[10] * zNear, frustumValues[11] * zNear, frustumValues[12] * zNear, frustumValues[13] * zNear, zNear, zFar);
 
                 distortionSet->setViewOffset(viewOffset);

experimental/distortionNG/DistortionSetupStrategyProjectionDesigner.cpp

@@ -24 +24 @@
 #include "DistortionSetupStrategyProjectionDesigner.h"
 
+CameraConfigParser::CameraConfigParser()
+{
+        configParsed = false;
+        frustumValues.clear();
+        rotationValues.clear();
+        rotationValues.resize(3,0);
+        translationValues.clear();
+        translationValues.resize(3,0);
+}
+
+bool CameraConfigParser::parseConfigFile(const char * filename)
+{
+        if (! osgDB::fileExists(filename) )
+        {
+                OSG_NOTIFY( osg::FATAL ) << "ERROR: File '" << filename << "' does not exist." << std::endl;
+                return false;
+        }
+
+        frustumValues.clear();
+        rotationValues.clear();
+        rotationValues.resize(3,0);
+        translationValues.clear();
+        translationValues.resize(3,0);
+
+        std::string line;
+        std::ifstream configFile (filename);
+
+        if (configFile.is_open())
+        {
+                while (! configFile.eof() )
+                {
+                        getline (configFile,line);
+
+                        // Auf Frustum untersuchen
+                        if( line.find("Frustum") != std::string::npos )
+                        {
+                                extractFrustum(line);
+                        }
+
+                        // Auf Rotation untersuchen
+                        if( line.find("Rotate") != std::string::npos )
+                        {
+                                extractRotation(line);
+                        }
+
+                        // Auf Translation untersuchens
+                        if( line.find("Translate") != std::string::npos )
+                        {
+                                extractTranslation(line);
+                        }
+                }
+                configFile.close();
+                configParsed = true;
+                return true;
+        }
+        else 
+        {
+                OSG_NOTIFY( osg::FATAL ) << "Unable to open file:" << filename << std::endl;
+                frustumValues.clear();
+                configParsed = false;
+                return false;
+        }
+}
+
+bool CameraConfigParser::extractFrustum(std::string data_)
+{
+        data_.replace(0,16,"");         // Delete leading spaces and "Frustum"
+        data_.replace(data_.length()-1,1,"");   // Delete trailing ";"
+        for( int i=0; i<6; i++)
+        {
+                size_t pos = data_.find(" ");    // Position of first value in string
+                if( pos == -1) pos = data_.length();
+                frustumValues.push_back( atof( data_.substr(0, pos).data() ) );
+                data_.replace(0,pos+1,"");
+        }
+        return true;
+}
+
+bool CameraConfigParser::extractRotation(std::string data_)
+{
+        data_.replace(0,15,"");         // Delete leading spaces and "Rotate"
+        data_.replace(data_.length()-1,1,"");   // Delete trailing ";"
+
+        size_t valuePos = data_.find(" ");    // First Value is RotationValue
+        std::string axis = data_.substr( valuePos+1);
+        switch(axis.find("1"))
+        {
+                case 0: rotationValues[0] = atof( data_.substr(0, valuePos).data() ); // X-Axis
+                        break;
+                case 2: rotationValues[1] = atof( data_.substr(0, valuePos).data() ); // Y-Axis
+                        break;
+                case 4: rotationValues[2] = atof( data_.substr(0, valuePos).data() ); // Z-Axis
+                        break;
+        };
+        return true;
+}
+
+bool CameraConfigParser::extractTranslation(std::string data_)
+{
+        data_.replace(0,18,"");         // Delete leading spaces and "Translate"
+        data_.replace(data_.length()-1,1,"");   // Delete trailing ";"
+        for( unsigned int i=0;i<translationValues.size(); i++)
+        {
+                size_t valuePos = data_.find(" ");
+                std::string value = data_.substr(0, valuePos);
+                data_.replace(0,valuePos+1,"");
+                translationValues[i] = atof( value.data() );
+        }
+        return true;
+}
+
 DistortionSetupStrategyProjectionDesigner::DistortionSetupStrategyProjectionDesigner()
 {
+        _blendmapFilename = "";
+        _frustumFilename = "";
+        _distortionFilename = "";
+        distortMapTexture = NULL;
         _distortionInitialized=false;
+        parser = new CameraConfigParser();
 }
 
@@ -34 +150 @@
 }
 
+osg::Texture* DistortionSetupStrategyProjectionDesigner::loadTexture( const std::string& fileName )
+{
+        std::string foundFileName = osgDB::findDataFile(fileName);
+        if (foundFileName.length() != 0 )
+        {
+                // load distortion map texture file
+                osg::Image* image = osgDB::readImageFile(foundFileName);
+                if (image)
+                {
+                        osg::Texture2D* texture = new osg::Texture2D;
+                        texture->setImage(image);
+                        texture->setFilter(osg::Texture2D::MIN_FILTER, osg::Texture2D::NEAREST);
+                        texture->setFilter(osg::Texture2D::MAG_FILTER, osg::Texture2D::NEAREST);
+                        texture->setWrap(osg::Texture2D::WRAP_S, osg::Texture2D::CLAMP_TO_EDGE);
+                        texture->setWrap(osg::Texture2D::WRAP_T, osg::Texture2D::CLAMP_TO_EDGE);
+                        return texture;
+                }
+        }
+
+        OSG_NOTIFY(osg::WARN) << "File \"" << fileName << "\" not found." << std::endl;
+
+        return NULL;
+}
+
+void DistortionSetupStrategyProjectionDesigner::setDistortionInputFiles(std::string distortionFile, std::string blendmapFile, std::string frustumFile)
+{
+        _blendmapFilename = blendmapFile;
+        _frustumFilename = frustumFile;
+        _distortionFilename = distortionFile;
+}
+
 void DistortionSetupStrategyProjectionDesigner::delegateDistortionSetup(osgViewer::DistortionSet* distortionSet)
 {
-        
-}
+        if(distortionSet == NULL)
+        {
+                OSG_ALWAYS<<"DistortionSetupStrategyProjectionDesigner::delegateDistortionSetup : Invalid DistortionSet"<<std::endl;
+                return;
+        }
+
+        if(      _blendmapFilename.empty() || _frustumFilename.empty() ||  _distortionFilename.empty() )
+        {
+                OSG_ALWAYS<<"DistortionSetupStrategyProjectionDesigner::delegateDistortionSetup : You have not specified the imput filenames correctly!"<<std::endl;
+                return;
+        }
+
+        if(     !osgDB::fileExists(_blendmapFilename) || !osgDB::fileExists(_frustumFilename) || !osgDB::fileExists(_distortionFilename) )
+        {
+                OSG_ALWAYS<<"DistortionSetupStrategyProjectionDesigner::delegateDistortionSetup : One of the specified input files does not exist!"<<std::endl;
+                return;
+        }
+
+        if (_distortionInitialized==false )
+        {
+                _distortionInitialized=true;
+                distortionSet->dirtyMesh();
+                distortionSet->dirtyMatrix();
+
+                // ******************** //
+                // *** IntensityMap *** //
+                // ******************** //
+
+                osg::Image* intensityMap=NULL;
+                intensityMap=osgDB::readImageFile(_blendmapFilename);
+                osg::GraphicsContext::WindowingSystemInterface* wsi = osg::GraphicsContext::getWindowingSystemInterface();
+                if (!wsi)
+                {
+                        OSG_NOTICE<<"Error, no WindowSystemInterface available, cannot create windows."<<std::endl;
+                        return;
+                }
+
+                osg::GraphicsContext::ScreenIdentifier si;
+                si.readDISPLAY();
+
+                if (si.displayNum<0) si.displayNum = 0;
+
+                si.screenNum = 0; //Fixed value, may be replaced later
+
+                unsigned int width=0, height=0;
+                wsi->getScreenResolution(si, width, height);
+
+                if(intensityMap->s()!=width || intensityMap->t()!=height)
+                        intensityMap->scaleImage(width, height, intensityMap->r());
+
+                // Copy image data and flag as dirty to update texture.
+                osg::copyImage(intensityMap, 0, 0, 0, intensityMap->s(), intensityMap->t(), intensityMap->r(), distortionSet->getIntensityMap(), 0, 0, 0, true);
+                distortionSet->getIntensityMap()->dirty();
+
+                // ******************************* //
+                // *** Frustum and View Offset *** //
+                // ******************************* //
+                parser->parseConfigFile((_frustumFilename).data());
+                if( parser->isConfigParsed())
+                {
+                        osg::Matrixd viewOffset=osg::Matrix::identity();
+                        osg::Matrixd projectionOffset=osg::Matrixd();
+
+                        osg::Matrixd rotViewOffset=osg::Matrixd();
+
+                        rotViewOffset.makeRotate(
+                                osg::DegreesToRadians((parser->getRotationDataset())[0]), osg::Vec3(0,1,0),     // heading
+                                osg::DegreesToRadians(-(parser->getRotationDataset())[1]), osg::Vec3(1,0,0),    // pitch
+                                osg::DegreesToRadians((parser->getRotationDataset())[2]), osg::Vec3(0,0,1));    // roll
+
+                        osg::Matrixd transViewOffset=osg::Matrixd();
+                        transViewOffset.makeTranslate( (parser->getTranslationDataset())[0], (parser->getTranslationDataset())[1], (parser->getTranslationDataset())[2]);
+
+                        viewOffset = viewOffset * rotViewOffset; // * transViewOffset;
+
+                        //Frustum Parameters: Left, Right, Bottom, Top, zNear, zFar.
+                        // Important: By definition of OpenGL, Left, Right, Bottom and Top must be set as tangens, multiplied by zNear!
+                        projectionOffset.makeFrustum(
+                                tanf((parser->getFrustumDataset())[0]) * (parser->getFrustumDataset())[4],
+                                tanf((parser->getFrustumDataset())[1]) * (parser->getFrustumDataset())[4],
+                                tanf((parser->getFrustumDataset())[2]) * (parser->getFrustumDataset())[4],
+                                tanf((parser->getFrustumDataset())[3]) * (parser->getFrustumDataset())[4],
+                                (parser->getFrustumDataset())[4],
+                                (parser->getFrustumDataset())[5]);
+
+                        distortionSet->setViewOffset(viewOffset);
+                        distortionSet->setProjectionOffset(projectionOffset);
+                }
+                else
+                {
+                        OSG_NOTIFY(osg::WARN) << "WARNING: Unable to parse Frustum values from '" << _frustumFilename << "' -- continue without valid frustum values." << std::endl;
+                }
+                // ******************************* //
+                // ******* Distortion Mesh ******* //
+                // ******************************* //
+
+                osg::Geometry* distortionMeshGeometry = distortionSet->getDistortionInternals()->getChild(osgViewer::DistortionSet::MESH)->asGeode()->getDrawable(0)->asGeometry();
+                if(distortionMeshGeometry)
+                {
+
+                        if ( osgDB::fileExists( _distortionFilename ) )
+                        {
+                                distortMapTexture = loadTexture(_distortionFilename);
+                                osg::Vec4Array* distortionMesh = new osg::Vec4Array;
+
+                                osg::Vec3 origin(0.0f,0.0f,0.0f);
+                                osg::Vec3 xAxis(1.0f,0.0f,0.0f);
+                                osg::Vec3 yAxis(0.0f,1.0f,0.0f);
+                                int noSteps = 128;
+
+                                osg::Vec3 bottom = origin;
+                                osg::Vec3 dx = xAxis*(width/((float)(noSteps-1)));
+                                osg::Vec3 dy = yAxis*(height/((float)(noSteps-1)));
+
+                                osg::Vec2 bottom_texcoord(0.0f,0.0f);
+                                osg::Vec2 dx_texcoord(1.0f/(float)(noSteps-1),0.0f);
+                                osg::Vec2 dy_texcoord(0.0f,1.0f/(float)(noSteps-1));
+
+                                osg::Vec2 texcoord = bottom_texcoord;
+                                int i,j;
+
+                                for(i=0;i<noSteps;++i)
+                                {
+                                        osg::Vec2 texcoord = bottom_texcoord+dy_texcoord*(float)i;
+                                        for(j=0;j<noSteps;++j)
+                                        {
+                                                if (distortMapTexture)
+                                                {
+                                                        osg::Vec2 imgcoord =    osg::Vec2((distortMapTexture->getImage(0)->s()-1) * texcoord.x(),
+                                                                                (distortMapTexture->getImage(0)->t()-1) * texcoord.y());
+                                                        unsigned char* pPixel = &distortMapTexture->getImage(0)->data()[(int)imgcoord.y()*distortMapTexture->getImage(0)->getRowSizeInBytes()+
+                                                                                (int)imgcoord.x()*distortMapTexture->getImage(0)->getPixelSizeInBits()/8];
+                                                        distortionMesh->push_back(osg::Vec4( texcoord.x(), texcoord.y(), ((float)pPixel[2] / 255.0f + (pPixel[0] % 16)) / 16.0f,
+                                                                                1.0f-((float)pPixel[1] / 255.0f + (pPixel[0] / 16)) / 16.0f));
+                                                }
+                                                texcoord += dx_texcoord;
+                                        }
+                                }
+
+                                distortionSet->setDistortionMesh(distortionMesh);
+                                distortionSet->setDistortionMeshDimensions(noSteps, noSteps);
+                        }
+                        else
+                        {
+                                OSG_NOTIFY(osg::WARN) << "WARNING: Unable to load Distortionmap '" << _distortionFilename << "' -- continue without distortion." << std::endl;
+                        }
+
+                }
+
+        }       
+}

experimental/distortionNG/DistortionSetupStrategyProjectionDesigner.h

@@ -19 +19 @@
 #pragma once
 
+#include <osgDB/FileUtils>
+#include <osg/Texture2D>
+
 #include "DistortionSetupStrategy.h"
+
+/**
+ * \brief This class parses the Projection Dsigner specific configuration files.
+ * 
+ * @author Torben Dannhauer
+ * @date  Aug 2012
+ */ 
+class CameraConfigParser : public osg::Referenced
+{
+public:
+        CameraConfigParser();
+        virtual ~CameraConfigParser() {};
+
+        bool parseConfigFile(const char * filename);
+
+        bool extractFrustum(std::string data_);
+        bool extractRotation(std::string data_);
+        bool extractTranslation(std::string data_);
+
+        std::vector<double> getFrustumDataset() {return(frustumValues);}        
+        std::vector<double> getRotationDataset() {return(rotationValues);}
+        std::vector<double> getTranslationDataset() {return(translationValues);}
+        bool isConfigParsed() {return configParsed;};
+
+private:
+        bool configParsed;
+        std::vector<double> frustumValues;
+        std::vector<double> rotationValues;
+        std::vector<double> translationValues;
+};
 
 
 /**
- * \brief "Project Syntropy" Setup Strategy reads setup files of http://www.project-syntropy.de/ and configures the distortion accordingly.
+ * \brief "Projection Designer" Setup Strategy reads setup files of Projection Designer and configures the distortion accordingly.
  * 
- * @author Torben Dannhauer
+ * @author Torben Dannhauer, Ludwig Friedmann
  * @date  Aug 2012
  */ 
@@ -35 +68 @@
         ~DistortionSetupStrategyProjectionDesigner();
         void delegateDistortionSetup(osgViewer::DistortionSet* distortionSet);
+        void setDistortionInputFiles(std::string distortionFile, std::string blendmapFile, std::string frustumFile);
+
+        std::vector<double> getFrustumDataset() {return parser->getFrustumDataset();};
+        
+        std::vector<double> getRotationDataset() {return parser->getRotationDataset();};
+
+        std::vector<double> getTranslationDataset() {return parser->getTranslationDataset();};
+
 private:
         bool _distortionInitialized;                            //Is Distortion already initialized?
+        std::string _blendmapFilename;
+        std::string _frustumFilename;
+        std::string _distortionFilename;
 
+
+
+        osg::Texture* loadTexture( const std::string& fileName );
+
+        osg::ref_ptr<CameraConfigParser> parser;
+        osg::ref_ptr<osg::Texture> distortMapTexture;
 };
+
+
+

experimental/distortionNG/main.cpp

@@ -38 +38 @@
 #include "DistortionManipulator.h"
 #include "DistortionSetupStrategyProjectSyntropy.h"
+#include "DistortionSetupStrategyProjectionDesigner.h"
 
 int main(int argc, char** argv)
@@ -98 +99 @@
                                                                                 "./resources/ProjectSyntropy/example2/blending_1.bmp",
                                                                                 "./resources/ProjectSyntropy/example2/frustum_1.csv" );
-        distortionManip->setDistortionSetupStrategy( psStrategy );
+
+        //LF UPDATE
+        DistortionSetupStrategyProjectionDesigner* pdStrategy = new DistortionSetupStrategyProjectionDesigner();
+        pdStrategy->setDistortionInputFiles( "./resources/ProjectionDesigner/example1/distort_center.bmp",
+                                                                                "./resources/ProjectionDesigner/example1/blend_center.bmp",
+                                                                                "./resources/ProjectionDesigner/example1/view_center.cfg" );
+
+
+        //Decide on DistortionSetupStrategy
+        //distortionManip->setDistortionSetupStrategy( psStrategy );
+        distortionManip->setDistortionSetupStrategy( pdStrategy );
         viewer.addEventHandler(distortionManip);
 
@@ -127 +138 @@
     // load the nodes from the commandline arguments.
     osg::Node* rootnode = osgDB::readNodeFiles(arguments);
+        osgDB::Registry::instance()->getDataFilePathList().push_front("./resources/");
         osgDB::Registry::instance()->getDataFilePathList().push_front("H:/AllInOnDB");
 
     if (!rootnode)
     {
-                rootnode = osgDB::readNodeFile("D:/osgVisual/experimental/distortionNG/resources/TestSphere/sphere_500.obj");
+                rootnode = osgDB::readNodeFile("./resources/TestSphere/sphere_500.obj");
                 if(!rootnode)
                 {