orca-robotics


INTRODUCTION
Overview
Download and Install
Quick Start
Documentation
Publications

REPOSITORY
Interfaces
Components
Libraries
Utilities
Software Map

DEVELOPER
Tutorials
Examples
Dev Guide
Dashboard
Wiki
login/pass: orca/orca

PEOPLE
Contributors
Users

SourceForge.net Logo
Project
Download
Mailing lists

 

         

simpleguielements.h

00001 /*
00002  * Orca-Robotics Project: Components for robotics 
00003  *               http://orca-robotics.sf.net/
00004  * Copyright (c) 2004-2008 Alex Brooks, Alexei Makarenko, Tobias Kaupp
00005  *
00006  * This copy of Orca is licensed to you under the terms described in
00007  * the LICENSE file included in this distribution.
00008  *
00009  */
00010 
00011 #ifndef ORCAGUI_SIMPLE_GUI_ELEMENTS_H
00012 #define ORCAGUI_SIMPLE_GUI_ELEMENTS_H
00013 
00014 // for setInit()
00015 #include <orcaobj/orcaobj.h>
00016 
00017 #include <orcaqguielementutil/ptricestormelement.h>
00018 #include <orcaqguielementutil/icestormelement.h>
00019 #include <hydroqgui/hydroqgui.h>
00020 #include <hydroqguielementutil/iknowsplatformposition2d.h>
00021 #include <orcaqgui2dfactory/connectutils.h>
00022 
00023 // Include various painter types
00024 #include <orcaqgui2dfactory/laserscanner2dpainter.h>
00025 #include <orcaqgui2dfactory/localise3dpainter.h>
00026 #include <orcaqgui2dfactory/odometry2dpainter.h>
00027 #include <orcaqgui2dfactory/particle2dpainter.h>
00028 #include <orcaqgui2dfactory/polarfeature2dpainter.h>
00029 #include <orcaqgui2dfactory/qgraphics2dpainter.h>
00030 
00031 //
00032 // A list of simple gui elements that listen to one icestorm topic, for one object type.
00033 //
00034 
00035 namespace orcaqgui2d
00036 {
00037 
00039 class PolarFeature2dElement
00040     : public orcaqguielementutil::IceStormElement<PolarFeature2dPainter,
00041                              orca::PolarFeature2dData,
00042                              orca::PolarFeature2dPrx,
00043                              orca::PolarFeature2dConsumer,
00044                              orca::PolarFeature2dConsumerPrx>
00045 {
00046 public:
00047     PolarFeature2dElement( const orcaice::Context  &context,
00048                            const std::string       &proxyString,
00049                            int                      timeoutMs=30000 )
00050         : orcaqguielementutil::IceStormElement<PolarFeature2dPainter,
00051                           orca::PolarFeature2dData,
00052                           orca::PolarFeature2dPrx,
00053                           orca::PolarFeature2dConsumer,
00054                           orca::PolarFeature2dConsumerPrx>( context, proxyString, painter_, timeoutMs )
00055           {};
00056 
00057     virtual bool isInGlobalCS() { return false; }
00058     virtual void actionOnConnection() 
00059     { 
00060         getExtractorInfo();
00061         paintInitialData<orca::PolarFeature2dPrx, PolarFeature2dPainter>
00062             ( context_, listener_.interfaceName(), painter_ ); 
00063     }
00064 
00065     virtual QStringList contextMenu();
00066 //     virtual void execute( int action ) { painter_.execute( action ); };
00067 
00068 private:
00069 
00070     void getExtractorInfo();
00071     PolarFeature2dPainter painter_;
00072 };
00073 
00075 class LaserScanner2dElement
00076     : public orcaqguielementutil::PtrIceStormElement<LaserScanner2dPainter,
00077                              orca::RangeScanner2dData,
00078                              orca::RangeScanner2dDataPtr,
00079                              orca::LaserScanner2dPrx,
00080                              orca::RangeScanner2dConsumer,
00081                              orca::RangeScanner2dConsumerPrx>
00082 {           
00083 public:
00084     LaserScanner2dElement( const orcaice::Context  &context,
00085                   const std::string       &proxyString,
00086                   int                      timeoutMs=30000,
00087                   QColor                   outlineColor=QColor( 102,102,153, 255 ),
00088                   float                    outlineThickness=-1,
00089                   float                    brightReturnWidth=0.2 )
00090         : orcaqguielementutil::PtrIceStormElement<LaserScanner2dPainter,
00091                           orca::RangeScanner2dData,
00092                           orca::RangeScanner2dDataPtr,
00093                           orca::LaserScanner2dPrx,
00094                           orca::RangeScanner2dConsumer,
00095                           orca::RangeScanner2dConsumerPrx>(context, proxyString, painter_, timeoutMs ),
00096           painter_( outlineColor, outlineThickness, brightReturnWidth )
00097         {};
00098 
00099     virtual bool isInGlobalCS() { return false; }
00100     virtual void actionOnConnection() { getLaserInfo(); }
00101     virtual QStringList contextMenu();
00102     virtual void execute( int action ) { painter_.execute( action ); };
00103     virtual void setColor( QColor color ) { painter_.setColor(color); }
00104     virtual void setFocus( bool inFocus ) { painter_.setFocus( inFocus ); };
00105 
00106 private:
00107     void getLaserInfo();
00108     LaserScanner2dPainter painter_;
00109     
00110 };
00111 
00113 class RangeScanner2dElement
00114     : public orcaqguielementutil::PtrIceStormElement<LaserScanner2dPainter,
00115                                 orca::RangeScanner2dData,
00116                                 orca::RangeScanner2dDataPtr,
00117                                 orca::RangeScanner2dPrx,
00118                                 orca::RangeScanner2dConsumer,
00119                                 orca::RangeScanner2dConsumerPrx>
00120 {           
00121 public:
00122     RangeScanner2dElement( const orcaice::Context  &context,
00123                   const std::string       &proxyString,
00124                   int                      timeoutMs=30000,
00125                   QColor                   outlineColor=QColor( 102,102,153, 255 ),
00126                   float                    outlineThickness=-1,
00127                   float                    brightReturnWidth=0.2 )
00128         : orcaqguielementutil::PtrIceStormElement<LaserScanner2dPainter,
00129                              orca::RangeScanner2dData,
00130                              orca::RangeScanner2dDataPtr,
00131                              orca::RangeScanner2dPrx,
00132                              orca::RangeScanner2dConsumer,
00133                              orca::RangeScanner2dConsumerPrx>(context, proxyString, painter_, timeoutMs ),
00134           painter_( outlineColor, outlineThickness, brightReturnWidth )
00135         {};
00136 
00137     virtual bool isInGlobalCS() { return false; }
00138     virtual void actionOnConnection() { getScannerInfo(); }
00139     virtual QStringList contextMenu();
00140     virtual void execute( int action ) { painter_.execute( action ); };
00141     virtual void setColor( QColor color ) { painter_.setColor(color); }
00142     virtual void setFocus( bool inFocus ) { painter_.setFocus( inFocus ); };
00143 
00144 private:
00145     void getScannerInfo();
00146     LaserScanner2dPainter painter_;
00147     
00148 };
00149 
00150 
00152 class Localise3dElement
00153     : public orcaqguielementutil::IceStormElement<Localise3dPainter,
00154                              orca::Localise3dData,
00155                              orca::Localise3dPrx,
00156                              orca::Localise3dConsumer,
00157                              orca::Localise3dConsumerPrx>,
00158       public hydroqguielementutil::IKnowsPlatformPosition2d
00159 {
00160 public:
00161     Localise3dElement( const orcaice::Context  &context,
00162                        const std::string       &proxyString,
00163                        bool                     beginDisplayHistory=false,
00164                        int                      timeoutMs=30000 )
00165         : orcaqguielementutil::IceStormElement<Localise3dPainter,
00166                             orca::Localise3dData,
00167                             orca::Localise3dPrx,
00168                             orca::Localise3dConsumer,
00169                             orca::Localise3dConsumerPrx>(context, proxyString, painter_, timeoutMs ),
00170           painter_( beginDisplayHistory ),
00171           x_(0),
00172           y_(0),
00173           theta_(0)
00174 {
00175     Ice::PropertiesPtr prop = context_.properties();
00176     std::string prefix = context_.tag();
00177     prefix += ".Config.";
00178 
00179     orcaobj::setInit( origin_ );
00180     orcaobj::getPropertyAsCartesianPoint( prop, prefix+"General.Offset", origin_ );
00181 
00182 }
00183     virtual bool isInGlobalCS() { return true; }
00184     virtual void actionOnConnection();
00185     virtual QStringList contextMenu();
00186     virtual void execute( int action );
00187     
00188     virtual void setColor( QColor color ) { painter_.setColor(color); }
00189     virtual void setFocus( bool inFocus ) { painter_.setFocus( inFocus ); };
00190     virtual void setUseTransparency( bool useTransparency ) { painter_.setUseTransparency( useTransparency ); };
00191 
00192     // Need a special update function to set (x,y,theta)
00193     // The Localise3dElement needs this because it's special kind of GuiElement:
00194     //   A platform has a position in the world and various other things are
00195     //   drawn with respect to that position.
00196     virtual void update();
00197 
00198     // Access to ML estimate.
00199     virtual double x() const { return x_; }
00200     virtual double y() const { return y_; }
00201     virtual double theta() const { return theta_; }
00202     virtual int platformKnowledgeReliability() const { return 7; }
00203     virtual QPointF pos() const { return QPointF(x_,y_); };
00204 
00205 private:
00206     Localise3dPainter painter_;
00207 
00208     double x_;
00209     double y_;
00210     double theta_;
00211     
00212     void tryToGetGeometry();
00213     bool haveGeometry_;
00214 
00215     orca::CartesianPoint origin_; 
00216 };
00217 
00219 
00220 class Particle2dElement
00221     : public orcaqguielementutil::IceStormElement<Particle2dPainter,
00222                              orca::Particle2dData,
00223                              orca::Particle2dPrx,
00224                              orca::Particle2dConsumer,
00225                              orca::Particle2dConsumerPrx>
00226 {
00227 public:
00228     Particle2dElement( const orcaice::Context  &context,
00229                        const std::string       &proxyString,
00230                        int                      timeoutMs=60000 )
00231         : orcaqguielementutil::IceStormElement<Particle2dPainter,
00232                             orca::Particle2dData,
00233                             orca::Particle2dPrx,
00234                             orca::Particle2dConsumer,
00235                             orca::Particle2dConsumerPrx>(context, proxyString, painter_, timeoutMs )
00236         {};
00237 
00238     virtual bool isInGlobalCS() { return true; }
00239     virtual void actionOnConnection()
00240     {
00241         paintInitialData<orca::Particle2dPrx, Particle2dPainter>
00242             ( context_, listener_.interfaceName(), painter_ );
00243     }
00244     virtual void setColor( QColor color ) { painter_.setColor(color); }
00245     virtual void setUseTransparency( bool useTransparency ) { painter_.setUseTransparency( useTransparency ); };
00246 
00247 private:
00248     Particle2dPainter painter_;
00249 };
00250 
00252 
00253 
00254 class QGraphics2dElement
00255     : public orcaqguielementutil::IceStormElement<QGraphics2dPainter,
00256                              orca::QGraphics2dData,
00257                              orca::QGraphics2dPrx,
00258                              orca::QGraphics2dConsumer,
00259                              orca::QGraphics2dConsumerPrx>
00260 {
00261 public:
00262     QGraphics2dElement( const orcaice::Context  &context,
00263                         const std::string       &proxyString,
00264                         int                      timeoutMs=-1 )
00265     : orcaqguielementutil::IceStormElement<QGraphics2dPainter,
00266                           orca::QGraphics2dData,
00267                           orca::QGraphics2dPrx,
00268                           orca::QGraphics2dConsumer,
00269                           orca::QGraphics2dConsumerPrx>(context, proxyString, painter_, timeoutMs )
00270     {
00271     };
00272 
00273     virtual bool isInGlobalCS() { return painter_.isInGlobalCS(); }
00274     virtual void actionOnConnection() 
00275     { 
00276         paintInitialData<orca::QGraphics2dPrx,QGraphics2dPainter>
00277             ( context_, listener_.interfaceName(), painter_ );
00278     }
00279 
00280 private:
00281     void getInitialAppearance();
00282     QGraphics2dPainter painter_;
00283 };
00284 
00286 class Odometry2dElement
00287     : public orcaqguielementutil::IceStormElement<Odometry2dPainter,
00288                              orca::Odometry2dData,
00289                              orca::Odometry2dPrx,
00290                              orca::Odometry2dConsumer,
00291                              orca::Odometry2dConsumerPrx>
00292 {
00293 public:
00294     Odometry2dElement( const orcaice::Context  &context,
00295                        const std::string       &proxyString,
00296                        int                      timeoutMs=60000 )
00297         : orcaqguielementutil::IceStormElement<Odometry2dPainter,
00298                             orca::Odometry2dData,
00299                             orca::Odometry2dPrx,
00300                             orca::Odometry2dConsumer,
00301                             orca::Odometry2dConsumerPrx>(context, proxyString, painter_, timeoutMs )
00302         {};
00303 
00304     virtual bool isInGlobalCS() { return false; }
00305     virtual void actionOnConnection()
00306     {
00307         paintInitialData<orca::Odometry2dPrx, Odometry2dPainter>
00308             ( context_, listener_.interfaceName(), painter_ );
00309     }
00310     virtual void setColor( QColor color ) { painter_.setColor(color); }
00311     virtual void setUseTransparency( bool useTransparency ) { painter_.setUseTransparency( useTransparency ); };
00312 
00313 private:
00314     Odometry2dPainter painter_;
00315 };
00316 
00317 } // namespace
00318 
00319 #endif
 

Webmaster: Tobias Kaupp (tobasco at users.sourceforge.net)


Generated for Orca Robotics by  doxygen 1.4.5