PSSources.h

Go to the documentation of this file.

/*********************************************************************
*
* Software License Agreement (BSD License)
*
*  Copyright (c) 2010, ISR University of Coimbra.
*  All rights reserved.
*
*  Redistribution and use in source and binary forms, with or without
*  modification, are permitted provided that the following conditions
*  are met:
*
*   * Redistributions of source code must retain the above copyright
*     notice, this list of conditions and the following disclaimer.
*   * Redistributions in binary form must reproduce the above
*     copyright notice, this list of conditions and the following
*     disclaimer in the documentation and/or other materials provided
*     with the distribution.
*   * Neither the name of the ISR University of Coimbra nor the names of its
*     contributors may be used to endorse or promote products derived
*     from this software without specific prior written permission.
*
*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
*  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
*  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
*  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
*  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
*  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
*  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
*  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
*  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
*  POSSIBILITY OF SUCH DAMAGE.
*
* Author: Gonçalo Cabrita and Pedro Sousa on 02/15/2010
*********************************************************************/
#include <vector>
#include <string>

#define MIN_NUM_OF_POINTS       20

namespace plumesim
{
        typedef struct
        {
                double px;
                double py;
        
        } PSPoint2d;

        typedef struct
        {
                double px;
                double py;
                double pz;

        } PSPoint3d;

        typedef struct
        {
                PSPoint2d startPoint;
                PSPoint2d endPoint;
        
        } PSRect;

        typedef struct
        {
                double chemical;                // ??
                double windSpeed;               // m/s
                double windDirection;   // rad
        
        } PSOdorData;

        typedef struct
        {
                PSPoint3d point;
                PSOdorData odor;
        
        } PSFramePoint;


        class PSSource
        {
                public:
                

                PSSource();

                ~PSSource();
        
                virtual int setup();
                virtual int cleanup();
        
                std::vector<PSPoint3d> plumePoints;             
                virtual int generatePoints();
                virtual int getChemicalReading(PSPoint3d * point, PSOdorData * odor_data);
                bool ChangesOverTime();
                bool IsPlaying();
                
                protected:
        
                float drand();
                double randomNormal();
                int countPoints(PSPoint3d * center, double radius);
                
                bool changesOverTime;           
                bool isPlaying;                         
        };


        class PSMeadering:public PSSource
        {
                public:
                
                PSMeadering();

                ~PSMeadering();
        
                int setup();
                int cleanup();
        
                int generatePoints();
                int getChemicalReading(PSPoint3d * point, PSOdorData * odor_data);
                
                // Preferences
                PSPoint3d startPoint;                           
                PSRect arenaRect;                                       
                double releaseRate;                                     
                double dispersionCoeficient;            
                double radius;                                          
                int maxPoints;                                          
                int numOfPlumePoints;                           
                private:
        
                void linearInterpolation(PSPoint3d * points, int numOfPoints);
        };


        class PSGaussian:public PSSource
        {
                public:
        
                PSGaussian();

                ~PSGaussian();
        
                int setup();
                int cleanup();
        
                int generatePoints();
                int getChemicalReading(PSPoint3d * point, PSOdorData * odor_data);
        
                // Preferences
                PSPoint3d startPoint;                           
                PSRect arenaRect;                                       
                double radius;                                          
                double cellSize;                                        
                int maxPointsPerCell;                           
                double diffX;                                           
                double diffY;                                           
                private:
        
                int t;                                                          
                std::vector<PSFramePoint> frame;        
        };


        class PSLog:public PSSource
        {
                public:
                
                PSLog();

                ~PSLog();
        
                int setup();
                int cleanup();
        
                int generatePoints();
                int getChemicalReading(PSPoint3d * point, PSOdorData * odor_data);
                
                // Preferences
                FILE * logFile;                         
                std::string logFilePath;                
                int period;                             
                int numOfFrames;                        
                int currentFrame;                       
                double cellSize;                        
                int maxPointsPerCell;                   
                private:
        
                std::vector<PSFramePoint> frame;        
        };


        class PSFluent:public PSSource
        {
                public:
        
                PSFluent();

                ~PSFluent();
        
                int setup();
                int cleanup();
        
                int generatePoints();
                int getChemicalReading(PSPoint3d * point, PSOdorData * odor_data);
        
                // Preferences
                FILE * logFile;                         
                std::string fileName;                   
                int numOfFrames;                        
                int currentFrame;                       
                double cellSize;                        
                int maxPointsPerCell;                   
                double maxOdorValue;                    
                private:
        
                std::vector<PSFramePoint> frame;        
        };

} // namespace

// EOF