Changeset 4028


Ignore:
Timestamp:
Nov 4, 2013 2:11:09 AM (8 years ago)
Author:
ldelgass
Message:

Add map layer commands

Location:
trunk/packages/vizservers/geovis
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • trunk/packages/vizservers/geovis/Makefile.in

    r4023 r4028  
    44USE_OFFSCREEN_RENDERING = #yes
    55USE_THREADS             = yes
     6USE_READ_THREAD         = #yes
    67
    78bindir          = @bindir@
     
    5051OSGEARTH_LIB_SPEC = -L${OSG_LIB_DIR} \
    5152                  -losgEarthFeatures \
     53                  -losgEarthAnnotation \
    5254                  -losgEarthSymbology \
    5355                  -losgEarthUtil \
    5456                  -losgEarth
    5557
    56 LD_RUN_PATH     = $(libdir)
     58LD_RUN_PATH     = $(OSG_LIB_DIR):$(libdir)
    5759
    5860LIBS            = \
     
    9092DEFINES         += -DUSE_THREADS
    9193endif
     94ifdef USE_READ_THREAD
     95DEFINES         += -DUSE_READ_THREAD
     96endif
    9297
    9398CXX_SWITCHES    = $(CXXFLAGS) $(EXTRA_CXXFLAGS) $(DEFINES) $(INCLUDES)
     
    105110
    106111ifdef USE_THREADS
    107 SERVER_SRCS+=ResponseQueue.cpp
     112SERVER_SRCS+= \
     113        ResponseQueue.cpp
     114ifdef USE_READ_THREAD
     115SERVER_SRCS+= \
     116        CommandQueue.cpp
     117endif
    108118endif
    109119
     
    142152
    143153CmdProc.o: CmdProc.h
     154CommandQueue.o: CommandQueue.h Trace.h
    144155md5.o: md5.h
    145156PPMWriter.o: PPMWriter.h ResponseQueue.h Trace.h
  • trunk/packages/vizservers/geovis/RenderServer.cpp

    r4025 r4028  
    3333#include <pthread.h>
    3434#include "ResponseQueue.h"
     35#ifdef USE_READ_THREAD
     36#include "CommandQueue.h"
     37#endif
    3538#endif
    3639#include <md5.h>
     
    4750Renderer *GeoVis::g_renderer = NULL; ///< Main render worker
    4851ReadBuffer *GeoVis::g_inBufPtr = NULL; ///< Socket read buffer
    49 ResponseQueue *GeoVis::g_queue = NULL;
     52#ifdef USE_THREADS
     53ResponseQueue *GeoVis::g_outQueue = NULL;
     54#ifdef USE_READER_THREAD
     55CommandQueue *GeoVis::g_inQueue = NULL;
     56#endif
     57#endif
    5058
    5159#ifdef USE_THREADS
     
    6674                 g_renderer->getWindowWidth(),
    6775                 g_renderer->getWindowHeight(),
    68                  TARGA_BYTES_PER_PIXEL);
     76                 TARGA_BYTES_PER_PIXEL,
     77                 true);
    6978#endif  /*RENDER_TARGA*/
    7079
     
    8392             g_renderer->getWindowHeight());
    8493#endif  /*RENDER_TARGA*/
    85 #endif  /*DEBUG*/
     94#endif  /*DEBUG_WRITE_FRAME_FILE*/
    8695}
    8796
     
    91100writeFrame(int fd, const unsigned char *imgData)
    92101{
    93 #ifdef DEBUG
    94     if (g_renderer->getCameraMode() == Renderer::IMAGE) {
    95         double xywh[4];
    96         g_renderer->getScreenWorldCoords(xywh);
    97         TRACE("Image bbox: %g %g %g %g",
    98               xywh[0],
    99               (xywh[1] + xywh[3]),
    100               (xywh[0] + xywh[2]),
    101               xywh[1]);
    102     }
     102#ifdef DEBUG_WRITE_FRAME_FILE
    103103
    104104#ifdef RENDER_TARGA
     
    118118
    119119#else
    120     if (g_renderer->getCameraMode() == Renderer::IMAGE) {
    121         double xywh[4];
    122         g_renderer->getCameraZoomRegion(xywh);
    123         std::ostringstream oss;
    124         oss.precision(12);
    125         // Send upper left and lower right corners as bbox
    126         oss << "nv>image -type image -bbox {"
    127             << std::scientific
    128             << xywh[0] << " "
    129             << xywh[1] << " "
    130             << xywh[2] << " "
    131             << xywh[3] << "} -bytes";
    132120
    133121#ifdef RENDER_TARGA
    134         writeTGA(fd, oss.str().c_str(),
    135                  imgData,
    136                  g_renderer->getWindowWidth(),
    137                  g_renderer->getWindowHeight(),
    138                  TARGA_BYTES_PER_PIXEL);
    139 #else
    140         writePPM(fd, oss.str().c_str(),
    141                  imgData->GetPointer(0),
    142                  g_renderer->getWindowWidth(),
    143                  g_renderer->getWindowHeight());
     122    writeTGA(fd, "nv>image -type image -bytes",
     123             imgData,
     124             g_renderer->getWindowWidth(),
     125             g_renderer->getWindowHeight(),
     126             TARGA_BYTES_PER_PIXEL);
     127#else
     128    writePPM(fd, "nv>image -type image -bytes",
     129             imgData,
     130             g_renderer->getWindowWidth(),
     131             g_renderer->getWindowHeight());
    144132#endif  /*RENDER_TARGA*/
    145     } else {
    146 #ifdef RENDER_TARGA
    147         writeTGA(fd, "nv>image -type image -bytes",
    148                  imgData,
    149                  g_renderer->getWindowWidth(),
    150                  g_renderer->getWindowHeight(),
    151                  TARGA_BYTES_PER_PIXEL);
    152 #else
    153         writePPM(fd, "nv>image -type image -bytes",
    154                  imgData,
    155                  g_renderer->getWindowWidth(),
    156                  g_renderer->getWindowHeight());
    157 #endif  /*RENDER_TARGA*/
    158     }
    159 #endif  /*DEBUG*/
     133#endif  /*DEBUG_WRITE_FRAME_FILE*/
    160134}
    161135#endif /*USE_THREADS*/
     
    419393#ifdef USE_THREADS
    420394
     395#ifdef USE_READ_THREAD
     396static void *
     397readerThread(void *clientData)
     398{
     399    Tcl_Interp *interp = (Tcl_Interp *)clientData;
     400
     401    TRACE("Starting reader thread");
     402
     403    queueCommands(interp, NULL, g_inBufPtr);
     404
     405    return NULL;
     406}
     407#endif
     408
    421409static void *
    422410writerThread(void *clientData)
     
    471459
    472460#ifdef USE_THREADS
    473     g_queue = new ResponseQueue();
     461    g_outQueue = new ResponseQueue();
    474462
    475463    pthread_t writerThreadId;
    476     if (pthread_create(&writerThreadId, NULL, &writerThread, g_queue) < 0) {
     464    if (pthread_create(&writerThreadId, NULL, &writerThread, g_outQueue) < 0) {
    477465        ERROR("Can't create writer thread: %s", strerror(errno));
    478466    }
     
    485473    for (;;) {
    486474        long timeout = g_renderer->getTimeout();
    487         if (processCommands(interp, NULL, g_inBufPtr, g_fdOut, timeout) < 0)
     475        int cmdStatus = processCommands(interp, NULL, g_inBufPtr, g_fdOut, timeout);
     476        if (cmdStatus < 0)
    488477            break;
    489478
     
    496485                TRACE("Image: %d x %d", imgData->s(), imgData->t());
    497486            }
    498 #ifdef USE_THREADS
    499             queueFrame(g_queue, imgData->data());
    500 #else
    501             writeFrame(g_fdOut, imgData->data());
    502 #endif
     487            if (imgData->s() == g_renderer->getWindowWidth() &&
     488                imgData->t() == g_renderer->getWindowHeight()) {
     489#ifdef USE_THREADS
     490                queueFrame(g_outQueue, imgData->data());
     491#else
     492                writeFrame(g_fdOut, imgData->data());
     493#endif
     494            }
    503495            g_stats.nFrames++;
    504             g_stats.nFrameBytes += 0; // FIXME
     496            g_stats.nFrameBytes += imgData->s() * imgData->t() * 3;
    505497        } else {
    506             TRACE("No render required");
    507             sendAck();
     498            //TRACE("No render required");
     499            if (cmdStatus > 1) {
     500                sendAck();
     501            }
    508502        }
    509503
     
    533527
    534528    TRACE("Deleting ResponseQueue");
    535     delete g_queue;
    536     g_queue = NULL;
     529    delete g_outQueue;
     530    g_outQueue = NULL;
    537531#endif
    538532
  • trunk/packages/vizservers/geovis/RenderServer.h

    r3998 r4028  
    1616class Renderer;
    1717class ReadBuffer;
     18class CommandQueue;
    1819class ResponseQueue;
    1920
     
    4950extern Renderer *g_renderer;
    5051extern ReadBuffer *g_inBufPtr;
    51 extern ResponseQueue *g_queue;
     52#ifdef USE_THREADS
     53#ifdef USE_READ_THREAD
     54extern CommandQueue *g_inQueue;
     55#endif
     56extern ResponseQueue *g_outQueue;
     57#endif
    5258extern int g_statsFile;
    5359extern int writeToStatsFile(int f, const char *s, size_t length);
  • trunk/packages/vizservers/geovis/Renderer.cpp

    r4027 r4028  
    1616#include <sys/time.h>
    1717#endif
     18
     19#include <osgGA/StateSetManipulator>
    1820
    1921#include <osgEarth/Version>
     
    5254    _captureCallback = new ScreenCaptureCallback();
    5355    _viewer->getCamera()->setPostDrawCallback(_captureCallback.get());
    54     _sceneRoot = new osg::Node;
     56    osgEarth::MapOptions mapOpts;
     57    mapOpts.coordSysType() = osgEarth::MapOptions::CSTYPE_PROJECTED;
     58    mapOpts.profile() = osgEarth::ProfileOptions("global-geodetic");
     59    osgEarth::Map *map = new osgEarth::Map(mapOpts);
     60    _map = map;
     61    osgEarth::MapNodeOptions mapNodeOpts;
     62    mapNodeOpts.enableLighting() = false;
     63    osgEarth::MapNode *mapNode = new osgEarth::MapNode(map, mapNodeOpts);
     64    _mapNode = mapNode;
     65    _sceneRoot = mapNode;
    5566    _viewer->setSceneData(_sceneRoot.get());
    5667    _manipulator = new osgEarth::Util::EarthManipulator;
    57     _viewer->setCameraManipulator(_manipulator);
     68    _viewer->setCameraManipulator(_manipulator.get());
     69    _viewer->addEventHandler(new osgGA::StateSetManipulator(_viewer->getCamera()->getOrCreateStateSet()));
    5870    _coordsCallback = new MouseCoordsCallback();
     71    _mouseCoordsTool = new osgEarth::Util::MouseCoordsTool(mapNode);
     72    _mouseCoordsTool->addCallback(_coordsCallback);
     73    _viewer->addEventHandler(_mouseCoordsTool);
    5974    _viewer->getCamera()->setNearFarRatio(0.00002);
    6075    _viewer->getCamera()->setSmallFeatureCullingPixelSize(-1.0f);
    6176    _viewer->setUpViewInWindow(0, 0, _windowWidth, _windowHeight);
    6277    _viewer->realize();
     78#ifdef DEBUG
    6379    if (_viewer->getViewerStats() != NULL) {
    6480        TRACE("Enabling stats");
    6581        _viewer->getViewerStats()->collectStats("scene", true);
    6682    }
     83#endif
     84#if 0
     85    osgViewer::ViewerBase::Windows windows;
     86    _viewer->getWindows(windows);
     87    if (windows.size() == 1) {
     88        windows[0]->setSyncToVBlank(false);
     89    } else {
     90        ERROR("Num windows: %lu", windows.size());
     91    }
     92#endif
     93}
     94
     95osgGA::EventQueue *Renderer::getEventQueue()
     96{
     97    osgViewer::ViewerBase::Windows windows;
     98    _viewer->getWindows(windows);
     99    return windows[0]->getEventQueue();
    67100}
    68101
     
    77110{
    78111    TRACE("Loading %s", path);
    79     _sceneRoot = osgDB::readNodeFile(path);
    80     osgEarth::MapNode *mapNode = osgEarth::MapNode::findMapNode(_sceneRoot.get());
     112    osg::Node *node = osgDB::readNodeFile(path);
     113    if (node == NULL) {
     114        ERROR("Couldn't load %s", path);
     115        return;
     116    }
     117    osgEarth::MapNode *mapNode = osgEarth::MapNode::findMapNode(node);
    81118    if (mapNode == NULL) {
    82119        ERROR("Couldn't find MapNode");
     120        return;
    83121    } else {
     122        _sceneRoot = node;
    84123        _map = mapNode->getMap();
    85124    }
     125    _mapNode = mapNode;
    86126    if (_mouseCoordsTool.valid())
    87         _viewer->removeEventHandler(_mouseCoordsTool);
     127        _viewer->removeEventHandler(_mouseCoordsTool.get());
    88128    _mouseCoordsTool = new osgEarth::Util::MouseCoordsTool(mapNode);
    89     _mouseCoordsTool->addCallback(_coordsCallback);
    90     _viewer->addEventHandler(_mouseCoordsTool);
     129    _mouseCoordsTool->addCallback(_coordsCallback.get());
     130    _viewer->addEventHandler(_mouseCoordsTool.get());
    91131    _viewer->setSceneData(_sceneRoot.get());
     132    _manipulator = new osgEarth::Util::EarthManipulator;
     133    _viewer->setCameraManipulator(_manipulator.get());
    92134    _manipulator->setNode(NULL);
    93135    _manipulator->setNode(_sceneRoot.get());
     
    97139}
    98140
     141void Renderer::resetMap(osgEarth::MapOptions::CoordinateSystemType type, const char *profile)
     142{
     143    TRACE("Restting map with type %d, profile %s", type, profile);
     144
     145    osgEarth::MapOptions mapOpts;
     146    mapOpts.coordSysType() = type;
     147    if (profile != NULL) {
     148        mapOpts.profile() = osgEarth::ProfileOptions(profile);
     149    } else if (type == osgEarth::MapOptions::CSTYPE_PROJECTED) {
     150        mapOpts.profile() = osgEarth::ProfileOptions("global-geodetic");
     151    }
     152    osgEarth::Map *map = new osgEarth::Map(mapOpts);
     153    _map = map;
     154    osgEarth::MapNodeOptions mapNodeOpts;
     155    mapNodeOpts.enableLighting() = false;
     156    osgEarth::MapNode *mapNode = new osgEarth::MapNode(map, mapNodeOpts);
     157    _mapNode = mapNode;
     158    _sceneRoot = mapNode;
     159    if (_mouseCoordsTool.valid())
     160        _viewer->removeEventHandler(_mouseCoordsTool.get());
     161    _mouseCoordsTool = new osgEarth::Util::MouseCoordsTool(mapNode);
     162    _mouseCoordsTool->addCallback(_coordsCallback.get());
     163    _viewer->addEventHandler(_mouseCoordsTool.get());
     164    _viewer->setSceneData(_sceneRoot.get());
     165    _manipulator = new osgEarth::Util::EarthManipulator;
     166    _viewer->setCameraManipulator(_manipulator.get());
     167    _manipulator->setNode(NULL);
     168    _manipulator->setNode(_sceneRoot.get());
     169    _manipulator->computeHomePosition();
     170    _viewer->home();
     171    _needsRedraw = true;
     172}
     173
     174bool Renderer::mapMouseCoords(float mouseX, float mouseY, osgEarth::GeoPoint& map)
     175{
     176    osg::Vec3d world;
     177    if (_mapNode->getTerrain()->getWorldCoordsUnderMouse(_viewer.get(), mouseX, mouseY, world)) {
     178        map.fromWorld(_mapNode->getMapSRS(), world);
     179        return true;
     180    }
     181    return false;
     182}
     183
    99184void Renderer::addImageLayer(const char *name, const osgEarth::TileSourceOptions& opts)
    100185{
     
    155240void Renderer::removeModelLayer(const char *name)
    156241{
    157 #if 1
    158242    osgEarth::ModelLayer *layer = _map->getModelLayerByName(name);
    159243    _map->removeModelLayer(layer);
    160 #endif
    161244}
    162245
    163246void Renderer::moveModelLayer(const char *name, unsigned int pos)
    164247{
    165 #if 1
    166248    osgEarth::ModelLayer *layer = _map->getModelLayerByName(name);
    167249    _map->moveModelLayer(layer, pos);
    168 #endif
    169250}
    170251
     
    267348}
    268349
     350void Renderer::setThrowingEnabled(bool state)
     351{
     352    _manipulator->getSettings()->setThrowingEnabled(state);
     353}
     354
    269355void Renderer::mouseDoubleClick(int button, double x, double y)
    270356{
    271     _viewer->getEventQueue()->mouseDoubleButtonPress((float)x, (float)y, button);
     357    getEventQueue()->mouseDoubleButtonPress((float)x, (float)y, button);
    272358    _needsRedraw = true;
    273359}
     
    275361void Renderer::mouseClick(int button, double x, double y)
    276362{
    277     _viewer->getEventQueue()->mouseButtonPress((float)x, (float)y, button);
     363    getEventQueue()->mouseButtonPress((float)x, (float)y, button);
    278364    _needsRedraw = true;
    279365}
     
    281367void Renderer::mouseDrag(int button, double x, double y)
    282368{
    283     _viewer->getEventQueue()->mouseMotion((float)x, (float)y);
     369    getEventQueue()->mouseMotion((float)x, (float)y);
    284370    _needsRedraw = true;
    285371}
     
    287373void Renderer::mouseRelease(int button, double x, double y)
    288374{
    289     _viewer->getEventQueue()->mouseButtonRelease((float)x, (float)y, button);
     375    getEventQueue()->mouseButtonRelease((float)x, (float)y, button);
    290376    _needsRedraw = true;
    291377}
     
    293379void Renderer::mouseMotion(double x, double y)
    294380{
    295     _viewer->getEventQueue()->mouseMotion((float)x, (float)y);
    296     _needsRedraw = true;
     381    //getEventQueue()->mouseMotion((float)x, (float)y);
     382    return;
     383    osgEarth::GeoPoint map;
     384    if (mapMouseCoords(x, y, map)) {
     385        _coordsCallback->set(map, _viewer.get(), _mapNode);
     386    } else {
     387        _coordsCallback->reset(_viewer.get(), _mapNode);
     388    }
    297389}
    298390
    299391void Renderer::mouseScroll(int direction)
    300392{
    301     _viewer->getEventQueue()->mouseScroll((direction > 0 ? osgGA::GUIEventAdapter::SCROLL_UP : osgGA::GUIEventAdapter::SCROLL_DOWN));
     393    getEventQueue()->mouseScroll((direction > 0 ? osgGA::GUIEventAdapter::SCROLL_UP : osgGA::GUIEventAdapter::SCROLL_DOWN));
    302394    _needsRedraw = true;
    303395}
     
    336428bool Renderer::isPagerIdle()
    337429{
    338     return (!_viewer->getDatabasePager()->requiresUpdateSceneGraph() &&
    339             !_viewer->getDatabasePager()->getRequestsInProgress());
     430    //return (!_viewer->getDatabasePager()->requiresUpdateSceneGraph() &&
     431    //        !_viewer->getDatabasePager()->getRequestsInProgress());
     432    return !_viewer->getDatabasePager()->requiresUpdateSceneGraph();
    340433}
    341434
     
    348441bool Renderer::render()
    349442{
    350     TRACE("Enter needsRedraw=%d",  _needsRedraw ? 1 : 0);
    351 
    352     if (_needsRedraw || !isPagerIdle()) {
     443    if (_needsRedraw ||
     444        //!isPagerIdle()
     445        _viewer->checkNeedToDoFrame()
     446        ) {
     447        TRACE("Enter needsRedraw=%d",  _needsRedraw ? 1 : 0);
     448
    353449        osg::Timer_t startFrameTick = osg::Timer::instance()->tick();
    354450        TRACE("Before frame()");
     
    364460        }
    365461#endif
     462#ifdef WANT_TRACE
    366463        if (_viewer->getViewerStats() != NULL) {
    367464            _viewer->getViewerStats()->report(std::cerr, _viewer->getViewerStats()->getLatestFrameNumber());
    368465        }
     466#endif
    369467        _needsRedraw = false;
    370468        return true;
  • trunk/packages/vizservers/geovis/Renderer.h

    r4025 r4028  
    3333
    3434// Controls if TGA format is sent to client
    35 #define RENDER_TARGA
     35//#define RENDER_TARGA
    3636#define TARGA_BYTES_PER_PIXEL 3
    3737
     
    4949    virtual void operator()(osg::RenderInfo &renderInfo) const
    5050    {
    51         TRACE("Enter");
     51        TRACE("Enter ScreenCaptureCallback");
    5252        int width, height;
    5353        if (renderInfo.getCurrentCamera() == NULL) {
     
    8888    {}
    8989
    90     void set(const osgEarth::GeoPoint& p, osg::View* view, osgEarth::MapNode* mapNode)
    91     {
    92         // p.y(), p.x()
     90    void set(const osgEarth::GeoPoint& p, osg::View *view, osgEarth::MapNode *mapNode)
     91    {
    9392        _pt = p;
    9493        _havePoint = true;
    9594    }
    9695
    97     void reset(osg::View* view, osgEarth::MapNode* mapNode)
     96    void reset(osg::View *view, osgEarth::MapNode *mapNode)
    9897    {
    9998        // Out of range click
    100         //_havePoint = false;
     99        _havePoint = false;
    101100    }
    102101
     
    131130    void loadEarthFile(const char *path);
    132131
     132    void resetMap(osgEarth::MapOptions::CoordinateSystemType type, const char *profile = NULL);
     133
     134    // Map options
     135
     136    void setLighting(bool state);
     137
    133138    // Image raster layers
    134139
     
    185190    // Mouse events
    186191
     192    void setThrowingEnabled(bool state);
     193
    187194    void mouseClick(int button, double x, double y);
    188195
     
    206213
    207214    osg::Image *getRenderedFrame();
     215
     216    bool mapMouseCoords(float mouseX, float mouseY, osgEarth::GeoPoint &pt);
    208217
    209218    bool getMousePoint(double *x, double *y, double *z)
     
    218227private:
    219228    void initCamera();
     229
     230    osgGA::EventQueue *getEventQueue();
    220231
    221232    bool _needsRedraw;
  • trunk/packages/vizservers/geovis/RendererCmd.cpp

    r4025 r4028  
    1919#include <tcl.h>
    2020
     21#include <osgEarthDrivers/gdal/GDALOptions>
     22
    2123#include "Trace.h"
    2224#include "CmdProc.h"
     
    2830#include "PPMWriter.h"
    2931#include "TGAWriter.h"
    30 #ifdef USE_THREADS
    3132#include "ResponseQueue.h"
     33#ifdef USE_READ_THREAD
     34#include "CommandQueue.h"
    3235#endif
    3336
     
    3639static int lastCmdStatus;
    3740
    38 ssize_t
    39 GeoVis::queueResponse(const void *bytes, size_t len,
    40                       Response::AllocationType allocType,
    41                       Response::ResponseType type)
    42 {
    43 #ifdef USE_THREADS
    44     Response *response = new Response(type);
    45     response->setMessage((unsigned char *)bytes, len, allocType);
    46     g_queue->enqueue(response);
    47     return (ssize_t)len;
    48 #else
    49     return SocketWrite(bytes, len);
    50 #endif
    51 }
    52 
     41#ifndef USE_THREADS
    5342static ssize_t
    5443SocketWrite(const void *bytes, size_t len)
     
    6655    return bytesWritten;
    6756}
     57#endif
    6858
    6959static bool
     
    7464    TRACE("followingData status: %d", status);
    7565    return (status == ReadBuffer::OK);
     66}
     67
     68ssize_t
     69GeoVis::queueResponse(const void *bytes, size_t len,
     70                      Response::AllocationType allocType,
     71                      Response::ResponseType type)
     72{
     73#ifdef USE_THREADS
     74    Response *response = new Response(type);
     75    response->setMessage((unsigned char *)bytes, len, allocType);
     76    g_outQueue->enqueue(response);
     77    return (ssize_t)len;
     78#else
     79    return SocketWrite(bytes, len);
     80#endif
    7681}
    7782
     
    192197
    193198static int
     199CameraThrowOp(ClientData clientData, Tcl_Interp *interp, int objc,
     200              Tcl_Obj *const *objv)
     201{
     202    bool state;
     203
     204    if (GetBooleanFromObj(interp, objv[2], &state) != TCL_OK) {
     205        return TCL_ERROR;
     206    }
     207
     208    g_renderer->setThrowingEnabled(state);
     209    return TCL_OK;
     210}
     211
     212static int
    194213CameraZoomOp(ClientData clientData, Tcl_Interp *interp, int objc,
    195214            Tcl_Obj *const *objv)
     
    210229    {"reset",  2, CameraResetOp, 2, 3, "?all?"},
    211230    {"rotate", 2, CameraRotateOp, 4, 4, "azimuth elevation"},
     231    {"throw",  1, CameraThrowOp, 3, 3, "bool"},
    212232    {"zoom",   1, CameraZoomOp, 3, 3, "zoomAmount"}
    213233};
     
    312332
    313333static int
     334MapLayerAddOp(ClientData clientData, Tcl_Interp *interp, int objc,
     335              Tcl_Obj *const *objv)
     336{
     337    osgEarth::Drivers::GDALOptions opts;
     338    char *url =  Tcl_GetString(objv[3]);
     339    char *name = Tcl_GetString(objv[4]);
     340
     341    opts.url() = url;
     342
     343    g_renderer->addImageLayer(name, opts);
     344
     345    return TCL_OK;
     346}
     347
     348static int
     349MapLayerDeleteOp(ClientData clientData, Tcl_Interp *interp, int objc,
     350                 Tcl_Obj *const *objv)
     351{
     352    if (objc > 3) {
     353        char *name = Tcl_GetString(objv[3]);
     354        g_renderer->removeImageLayer(name);
     355    } else {
     356        g_renderer->removeImageLayer("all");
     357    }
     358
     359    return TCL_OK;
     360}
     361
     362static int
     363MapLayerMoveOp(ClientData clientData, Tcl_Interp *interp, int objc,
     364               Tcl_Obj *const *objv)
     365{
     366    int pos;
     367    if (Tcl_GetIntFromObj(interp, objv[3], &pos) != TCL_OK) {
     368        return TCL_ERROR;
     369    }
     370    char *name = Tcl_GetString(objv[4]);
     371    if (pos < 0) {
     372        Tcl_AppendResult(interp, "bad layer pos ", pos,
     373                         ": must be positive", (char*)NULL);
     374        return TCL_ERROR;
     375    }
     376    g_renderer->moveImageLayer(name, (unsigned int)pos);
     377
     378    return TCL_OK;
     379}
     380
     381static int
     382MapLayerOpacityOp(ClientData clientData, Tcl_Interp *interp, int objc,
     383                  Tcl_Obj *const *objv)
     384{
     385    double opacity;
     386    if (Tcl_GetDoubleFromObj(interp, objv[3], &opacity) != TCL_OK) {
     387        return TCL_ERROR;
     388    }
     389    char *name = Tcl_GetString(objv[4]);
     390    if (opacity < 0.0 || opacity > 1.0) {
     391        Tcl_AppendResult(interp, "bad layer opacity ", opacity,
     392                         ": must be [0,1]", (char*)NULL);
     393        return TCL_ERROR;
     394    }
     395    g_renderer->setImageLayerOpacity(name, opacity);
     396
     397    return TCL_OK;
     398}
     399
     400static int
     401MapLayerVisibleOp(ClientData clientData, Tcl_Interp *interp, int objc,
     402                  Tcl_Obj *const *objv)
     403{
     404    bool visible;
     405    if (GetBooleanFromObj(interp, objv[3], &visible) != TCL_OK) {
     406        return TCL_ERROR;
     407    }
     408    char *name = Tcl_GetString(objv[4]);
     409
     410    g_renderer->setImageLayerVisibility(name, visible);
     411
     412    return TCL_OK;
     413}
     414
     415static Rappture::CmdSpec mapLayerOps[] = {
     416    {"add",     1, MapLayerAddOp,       5, 5, "type url name"},
     417    {"delete",  1, MapLayerDeleteOp,    3, 4, "?name?"},
     418    {"move",    1, MapLayerMoveOp,      5, 5, "pos name"},
     419    {"opacity", 1, MapLayerOpacityOp,   5, 5, "opacity ?name?"},
     420    {"visible", 1, MapLayerVisibleOp,   5, 5, "bool ?name?"},
     421};
     422static int nMapLayerOps = NumCmdSpecs(mapLayerOps);
     423
     424static int
     425MapLayerOp(ClientData clientData, Tcl_Interp *interp, int objc,
     426           Tcl_Obj *const *objv)
     427{
     428    Tcl_ObjCmdProc *proc;
     429
     430    proc = Rappture::GetOpFromObj(interp, nMapLayerOps, mapLayerOps,
     431                                  Rappture::CMDSPEC_ARG2, objc, objv, 0);
     432    if (proc == NULL) {
     433        return TCL_ERROR;
     434    }
     435    return (*proc) (clientData, interp, objc, objv);
     436}
     437
     438static int
     439MapLoadOp(ClientData clientData, Tcl_Interp *interp, int objc,
     440          Tcl_Obj *const *objv)
     441{
     442    char *opt = Tcl_GetString(objv[2]);
     443    if (opt[0] == 'f' && strcmp(opt, "file") == 0) {
     444        g_renderer->loadEarthFile(Tcl_GetString(objv[3]));
     445    } else if (opt[0] == 'u' && strcmp(opt, "url") == 0) {
     446        std::ostringstream path;
     447        path << "server:" << Tcl_GetString(objv[3]);
     448        g_renderer->loadEarthFile(path.str().c_str());
     449    } else if (opt[0] == 'd' && strcmp(opt, "data") == 0) {
     450        opt = Tcl_GetString(objv[3]);
     451        if (opt[0] != 'f' || strcmp(opt, "follows") != 0) {
     452            return TCL_ERROR;
     453        }
     454        int len;
     455        if (Tcl_GetIntFromObj(interp, objv[4], &len) != TCL_OK) {
     456            return TCL_ERROR;
     457        }
     458        // Read Earth file from socket
     459        char *buf = (char *)malloc((size_t)len);
     460        SocketRead(buf, (size_t)len);
     461        std::ostringstream path;
     462        path << "/tmp/tmp" << getpid() << ".earth";
     463        FILE *tmpFile = fopen(path.str().c_str(), "w");
     464        fwrite(buf, len, 1, tmpFile);
     465        fclose(tmpFile);
     466        g_renderer->loadEarthFile(path.str().c_str());
     467        unlink(path.str().c_str());
     468        free(buf);
     469    } else {
     470        return TCL_ERROR;
     471    }
     472    return TCL_OK;
     473}
     474
     475static int
     476MapResetOp(ClientData clientData, Tcl_Interp *interp, int objc,
     477           Tcl_Obj *const *objv)
     478{
     479    char *typeStr = Tcl_GetString(objv[2]);
     480    osgEarth::MapOptions::CoordinateSystemType type;
     481    if (typeStr[0] == 'g' && strcmp(typeStr, "geocentric") == 0) {
     482        type = osgEarth::MapOptions::CSTYPE_GEOCENTRIC;
     483    } else if (typeStr[0] == 'g' && strcmp(typeStr, "geocentric_cube") == 0) {
     484        type = osgEarth::MapOptions::CSTYPE_GEOCENTRIC_CUBE;
     485    } else if (typeStr[0] == 'p' && strcmp(typeStr, "projected") == 0) {
     486        type = osgEarth::MapOptions::CSTYPE_PROJECTED;
     487    } else {
     488        Tcl_AppendResult(interp, "bad map type \"", typeStr,
     489                         "\": must be geocentric, geocentric_cube or projected", (char*)NULL);
     490        return TCL_ERROR;
     491    }
     492
     493    char *profile = NULL;
     494    if (objc > 3) {
     495        profile = Tcl_GetString(objv[3]);
     496    }
     497
     498    g_renderer->resetMap(type, profile);
     499
     500    return TCL_OK;
     501}
     502
     503static Rappture::CmdSpec mapOps[] = {
     504    {"layer",    2, MapLayerOp,       3, 5, "op ?params...?"},
     505    {"load",     2, MapLoadOp,        4, 5, "options"},
     506    {"reset",    1, MapResetOp,       3, 4, "type ?profile?"},
     507};
     508static int nMapOps = NumCmdSpecs(mapOps);
     509
     510static int
     511MapCmd(ClientData clientData, Tcl_Interp *interp, int objc,
     512       Tcl_Obj *const *objv)
     513{
     514    Tcl_ObjCmdProc *proc;
     515
     516    proc = Rappture::GetOpFromObj(interp, nMapOps, mapOps,
     517                                  Rappture::CMDSPEC_ARG1, objc, objv, 0);
     518    if (proc == NULL) {
     519        return TCL_ERROR;
     520    }
     521    return (*proc) (clientData, interp, objc, objv);
     522}
     523
     524static int
    314525MouseClickOp(ClientData clientData, Tcl_Interp *interp, int objc,
    315526             Tcl_Obj *const *objv)
     
    441652
    442653static int
    443 RendererLoadOp(ClientData clientData, Tcl_Interp *interp, int objc,
    444                Tcl_Obj *const *objv)
    445 {
    446     g_renderer->loadEarthFile(Tcl_GetString(objv[2]));
    447     return TCL_OK;
    448 }
    449 
    450 static int
    451654RendererRenderOp(ClientData clientData, Tcl_Interp *interp, int objc,
    452655                 Tcl_Obj *const *objv)
     
    457660
    458661static Rappture::CmdSpec rendererOps[] = {
    459     {"load",       1, RendererLoadOp, 3, 3, "path"},
    460662    {"render",     1, RendererRenderOp, 2, 2, ""},
    461663};
     
    526728    return (*proc) (clientData, interp, objc, objv);
    527729}
     730
     731#ifdef USE_READ_THREAD
     732int
     733GeoVis::queueCommands(Tcl_Interp *interp,
     734                      ClientData clientData,
     735                      ReadBuffer *inBufPtr)
     736{
     737    Tcl_DString commandString;
     738    Tcl_DStringInit(&commandString);
     739    fd_set readFds;
     740
     741    FD_ZERO(&readFds);
     742    FD_SET(inBufPtr->file(), &readFds);
     743    while (inBufPtr->isLineAvailable() ||
     744           (select(1, &readFds, NULL, NULL, NULL) > 0)) {
     745        size_t numBytes;
     746        unsigned char *buffer;
     747
     748        /* A short read is treated as an error here because we assume that we
     749         * will always get commands line by line. */
     750        if (inBufPtr->getLine(&numBytes, &buffer) != ReadBuffer::OK) {
     751            /* Terminate the server if we can't communicate with the client
     752             * anymore. */
     753            if (inBufPtr->status() == ReadBuffer::ENDFILE) {
     754                TRACE("Exiting server on EOF from client");
     755                return -1;
     756            } else {
     757                ERROR("Exiting server, failed to read from client: %s",
     758                      strerror(errno));
     759                return -1;
     760            }
     761        }
     762        Tcl_DStringAppend(&commandString, (char *)buffer, numBytes);
     763        if (Tcl_CommandComplete(Tcl_DStringValue(&commandString))) {
     764            // Add to queue
     765            Command *command = new Command(Command::COMMAND);
     766            command->setMessage((unsigned char *)Tcl_DStringValue(&commandString),
     767                                Tcl_DStringLength(&commandString), Command::VOLATILE);
     768            g_inQueue->enqueue(command);
     769            Tcl_DStringSetLength(&commandString, 0);
     770        }
     771        FD_SET(inBufPtr->file(), &readFds);
     772    }
     773
     774    return 1;
     775}
     776#endif
    528777
    529778/**
     
    592841            g_stats.nCommands++;
    593842            if (status == TCL_BREAK) {
    594                 return 1;               /* This was caused by a "imgflush"
     843                return 2;               /* This was caused by a "imgflush"
    595844                                         * command. Break out of the read loop
    596845                                         * and allow a new image to be
     
    602851                }
    603852            }
     853            if (status == TCL_OK) {
     854                ret = 3;
     855            }
    604856        }
    605857
     
    671923    Tcl_CreateObjCommand(interp, "clientinfo",     ClientInfoCmd,     clientData, NULL);
    672924    Tcl_CreateObjCommand(interp, "imgflush",       ImageFlushCmd,     clientData, NULL);
     925    Tcl_CreateObjCommand(interp, "map",            MapCmd,            clientData, NULL);
    673926    Tcl_CreateObjCommand(interp, "mouse",          MouseCmd,          clientData, NULL);
    674927    Tcl_CreateObjCommand(interp, "renderer",       RendererCmd,       clientData, NULL);
     
    684937    Tcl_DeleteCommand(interp, "clientinfo");
    685938    Tcl_DeleteCommand(interp, "imgflush");
     939    Tcl_DeleteCommand(interp, "map");
    686940    Tcl_DeleteCommand(interp, "mouse");
    687941    Tcl_DeleteCommand(interp, "renderer");
  • trunk/packages/vizservers/geovis/RendererCmd.h

    r4025 r4028  
    1313
    1414#include "ReadBuffer.h"
    15 #ifdef USE_THREADS
    1615#include "ResponseQueue.h"
    17 #endif
    1816
    1917namespace GeoVis {
    2018
    21 #ifdef USE_THREADS
    2219extern ssize_t queueResponse(const void *bytes, size_t len,
    2320                             Response::AllocationType allocType,
    2421                             Response::ResponseType type = Response::DATA);
     22
     23#ifdef USE_READ_THREAD
     24extern int queueCommands(Tcl_Interp *interp,
     25                         ClientData clientData,
     26                         ReadBuffer *inBufPtr);
    2527#endif
    2628
  • trunk/packages/vizservers/geovis/TGAWriter.cpp

    r3998 r4028  
    138138    iov[1].iov_len = headerLength;
    139139    // Image data **must be BGR(A)!**
    140     iov[2].iov_base = data;
     140    iov[2].iov_base = const_cast<unsigned char *>(data);
    141141    iov[2].iov_len = dataLength;
    142142
Note: See TracChangeset for help on using the changeset viewer.