source: experimental/distortionNG/main.cpp @ 342

/* osgVisual test. distortionNG, experimental.
*
*  Permission is hereby granted, free of charge, to any person obtaining a copy
*  of this software and associated documentation files (the "Software"), to deal
*  in the Software without restriction, including without limitation the rights
*  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
*  copies of the Software, and to permit persons to whom the Software is
*  furnished to do so, subject to the following conditions:
*
*  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
*  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
*  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
*  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
*  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
*  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
*  THE SOFTWARE.
*/

#include "extViewer.h"
#include "distortionNG.h"

#include <osg/ArgumentParser>
#include <osg/PolygonOffset>

#include <osgDB/ReadFile>

#include <osgViewer/Viewer>
#include <osgViewer/ViewerEventHandlers>

#include <osgGA/TrackballManipulator>
#include <osgGA/FlightManipulator>
#include <osgGA/DriveManipulator>
#include <osgGA/KeySwitchMatrixManipulator>
#include <osgGA/StateSetManipulator>
#include <osgGA/AnimationPathManipulator>
#include <osgGA/TerrainManipulator>
int main(int argc, char** argv)
{
    osg::ArgumentParser arguments(&argc, argv);

    // construct the viewer.
    extViewer viewer(arguments);

        osg::Image* intMap = osgDB::readImageFile("intensitymap.png");
        if (!intMap)
        {
                osg::notify(osg::WARN) << "Couldn't find intensity map, quiting." << std::endl;
                return -1;
        } 

        viewer.setUpViewForManualDistortion(0, intMap);
        //viewer.setUpViewForPanoramicSphericalDisplay(1, 0, 0, intMap);
    
        // set up the camera manipulators.
    {
        osg::ref_ptr<osgGA::KeySwitchMatrixManipulator> keyswitchManipulator = new osgGA::KeySwitchMatrixManipulator;

        keyswitchManipulator->addMatrixManipulator( '1', "Trackball", new osgGA::TrackballManipulator() );
        keyswitchManipulator->addMatrixManipulator( '2', "Flight", new osgGA::FlightManipulator() );
        keyswitchManipulator->addMatrixManipulator( '3', "Drive", new osgGA::DriveManipulator() );
        keyswitchManipulator->addMatrixManipulator( '4', "Terrain", new osgGA::TerrainManipulator() );

        std::string pathfile;
        char keyForAnimationPath = '5';
        while (arguments.read("-p",pathfile))
        {
            osgGA::AnimationPathManipulator* apm = new osgGA::AnimationPathManipulator(pathfile);
            if (apm || !apm->valid()) 
            {
                unsigned int num = keyswitchManipulator->getNumMatrixManipulators();
                keyswitchManipulator->addMatrixManipulator( keyForAnimationPath, "Path", apm );
                keyswitchManipulator->selectMatrixManipulator(num);
                ++keyForAnimationPath;
            }
        }

        viewer.setCameraManipulator( keyswitchManipulator.get() );
    }


    // add the state manipulator
    viewer.addEventHandler( new osgGA::StateSetManipulator(viewer.getCamera()->getOrCreateStateSet()) );

    // add the stats handler
    viewer.addEventHandler(new osgViewer::StatsHandler);

    // add the record camera path handler
    viewer.addEventHandler(new osgViewer::RecordCameraPathHandler);

    // add the window size toggle handler
    viewer.addEventHandler(new osgViewer::WindowSizeHandler);

        // add the thread model handler
    viewer.addEventHandler(new osgViewer::ThreadingHandler);

    // add the help handler
    viewer.addEventHandler(new osgViewer::HelpHandler(arguments.getApplicationUsage()));

    // add the LOD Scale handler
    viewer.addEventHandler(new osgViewer::LODScaleHandler);

    // add the screen capture handler
    viewer.addEventHandler(new osgViewer::ScreenCaptureHandler);

    // load the nodes from the commandline arguments.
    osg::Node* rootnode = osgDB::readNodeFiles(arguments);

    if (!rootnode)
    {
                rootnode = osgDB::readNodeFile("cow.osgt");
                if(!rootnode)
                {
                        osg::notify(osg::WARN)<<"Warning: no valid data loaded, please specify a database on the command line."<<std::endl;
                        return 1;
                }
    }
        viewer.setSceneData( rootnode );

        //osg::ref_ptr<osg::Geode> geode = new osg::Geode;
        //geode->addDrawable( extViewer::createMesh(16, 9) );
        //geode->getOrCreateStateSet()->setMode( GL_LIGHTING, osg::StateAttribute::OFF );
        //geode->getOrCreateStateSet()->setAttributeAndModes( new osg::PolygonOffset(1.0f, 1.0f) );

        //osg::ref_ptr<distortionHandler> selector = new distortionHandler( viewer.getCamera() );

        //osg::ref_ptr<osg::Group> root = new osg::Group;
        //root->addChild( geode.get() );
        //root->addChild( selector->createVertexHighlighter() );
        //viewer.addEventHandler( selector.get() );
        //viewer.setSceneData( root.get() );

        // Avoid that the highlighter is culled away
        //osg::CullSettings::CullingMode mode = viewer.getCamera()->getCullingMode();
        //viewer.getCamera()->setCullingMode( mode & (~osg::CullSettings::SMALL_FEATURE_CULLING) );
        
        // run the viewers main loop
        return viewer.run();
}

/*
ToDo: 

The intersection works and the selector highlighter is set and displayed correctly.
Next steps:
 * Hide the highlighter and disable the intersection/drag tracking on diabled edit mode.
 * catch up dragging values and translate them in the correct coordinate frame.
 * apply dragging values:
 *      a) either on the texture coordinate while the grid is constant,
 *  b) or apply them on the grid node coordinates while the texture coordinates are constant (check/compare solutions!)
 * 
 

 * 
 * Layout vom Distortion System
 * 
 * Das distortion systme unterstüzt verzerrungen ,die pro kanal auhc nur eine camera verwenden.
 * Verzerrungen, die das Bild je Kanal aus mehreren Cams zusammensetzen um Views>=180° zu erreichen werden nicht unterstützt da hierfür das Camera Setup nötig wäre, welches nicht im distortion-Container gespeichert wird (Sonderfall, zu speziell für das Dist-Framework)
 * 
 * 
 * modul                                                                Funktionen / Description
 * 
 * plugin .dist                                                 load / Save distContainers                                      loads and saves via serializers the distortion container from/to file.
 * 
 * 
 * Distortion Container                                 Beinhaltet die folgenden Distortion Details:
 *                                                                              - Blendmap (osgImage) 
 *                                                                              - Mesh Dimensions (rows, columns)
 *                                                                              - Mesh Type (osg::PrimitiveSet::QUAD_STRIP, ...)
 *                                                                              - textureUnit for Scene RTT (z.B.: 0)
 *                                                                              - textureUnit for blendmap (z.B.: 1)
 *                                                                              - screenNum
 *                                                                              - slaveCam projectionOffset (wird mit der vom master multipliziert und auf die slave cam angewendet, meist identity)
 *                                                                              - slaveCam viewOffset   (wird mit der vom master multipliziert und auf die slave cam angewendet, verwendet für translation und rotation offset)
 *                                                                              
 *                                                                              need to add setter/getter as well as the serializer macros.
 * 
 * 
 * osgViewer                                                    load and apply distortion (apply via setupDistortion(...)
 *                                                                              setUpIntensityMapBlending(string filepath, int rrtTexUnit=1, int scenTexUnit=0): simple function providing a file path, and optionally the texUnits to use. Wil invoke the more detailed funtion for setup.
 *                                                                              setUpIntensityMapBlending(osg::StateSet* stateset, osg::Image* intensityMap, unsigned int screenNum, int rttSceneTextureUnit, int intensityMapTextureUnit)
 * 
 * 
 * distortionManipulator                                abgeleitet von osgGA::GUIEventHandler
 *                                                                              Grundfunktionen:
 *                                                                              - Key for Show/Hide Distortion Mesh
 *                                                                              - Key for Save distortion Handler  - via plugin
 *                                                                              - Key for toggle distortion setup: 
 *                                                                                              DISABLED distortion modifications are forbidden (ggfs beim verlassen von DISABLED ggf. auf singleThreaded wechseln und beim aktivieren von DISABLED wieder auf das alte threadingmodel. Alternativ  die data variance des meshes beeinflussen)
 *                                                                                              MANUAL distortion modification via mouse Selection and drag'n'drop
 *                                                                                              DELEGATED via calling a foreign class or calling a subclassed function
 *                                                                              - Key to control if mouse drags affects mesh coordinates or texture coordinates. Default: Mesh coordinates.
 *                                                                              - Key to reset Distortion.
 *                                                                              
 *                                                                              Die Funktion  handle( const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa ):
 *                                                                                      DISABLED: ignorieren
 *                                                                                      MANUAL : auf mouse selection und drags horchen und auf Distortion Anwenden. bei keys die obigen funktionen realisieren
 *                                                                                      DELEGATED : beim typ FRAME die Distortion zur Veränderung stellen indem der Pointer an die bearbeitende Funktion übergeben wird:
 *                                                                                                                              subsclassed function aufrufen bzw foreignClass->delegateDistortionSetup(distContainer& container)
 *                                                                                      
 *                                                                              Vertex Highlighter für die Manuelle Verzerrung soll nur eingeblendet werden wenn der Betriebsmodus MANUAL ist.
 * 
 *                                                                              
 * blending Manipulator                                 abgeleitet von osgGA::GUIEventHandler
 *                                                                              Grundfunktionen:
 * 
 *                                                                              - To Do
 *                                                                              
 * 
 * 
 * 
*/