stf.h

Go to the documentation of this file.

// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
 
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

 
#ifndef _STF_H_
#define _STF_H_
 
#ifndef _WINDOWS
#if (__cplusplus < 201103)
    #include <boost/function.hpp>
#else
    #include <algorithm>
    #include <memory>
#endif
#endif
 
#if (__GNUC__ > 5)
  #include <functional>
#endif
#include <vector>
#include <map>
#include <string>
 
#include "./gui/zoom.h"
 
#ifdef _MSC_VER
#pragma warning( disable : 4251 )  // Disable warning messages
#pragma warning( disable : 4996 )  // Disable warning messages
#endif

#if defined(_WINDOWS) && !defined(__MINGW32__)
    #ifdef STFDLL
        #define StfDll __declspec( dllexport )
    #else
        #define StfDll __declspec( dllimport )
    #endif
#else
    #define StfDll
#endif
 
#ifndef MODULE_ONLY
    #include <wx/wxprec.h>
    #ifdef __BORLANDC__
        #pragma hdrstop
    #endif
 
    #ifndef WX_PRECOMP
        #include <wx/wx.h>
        #include <wx/aui/aui.h>
        #include <wx/docview.h>
        #include <wx/docmdi.h>
    #endif
 
    #include <wx/wfstream.h>
    #include <wx/progdlg.h>
    // typedef wxDocChildFrameAny<wxAuiMDIChildFrame, wxAuiMDIParentFrame> wxStfChildType;
    #ifdef STF_TEST
        typedef int wxStfChildType;
        typedef int wxStfParentType;
    #else
        typedef wxDocMDIChildFrame wxStfChildType;

        typedef wxDocMDIParentFrame wxStfParentType;
    #endif
#else
    typedef std::string wxString;
    typedef int wxWindow;
    #define wxT(x)  x
    #define wxCHECK_VERSION(major,minor,release) 0
#endif
 
#include "../libstfio/stfio.h"
#include "../libstfnum/stfnum.h"


namespace stf {


class wxProgressInfo : public stfio::ProgressInfo {
public:
    wxProgressInfo(const std::string& title, const std::string& message, int maximum, bool verbose=true);
    bool Update(int value, const std::string& newmsg="", bool* skip=NULL);
private:
    wxProgressDialog pd;
};
 
std::string wx2std(const wxString& wxs);
wxString std2wx(const std::string& sst);
 

wxString sectionToString(const Section& section);
 

wxString CreatePreview(const wxString& fName);
 

wxString noPath(const wxString& fName);

#if (__cplusplus < 201103)
typedef boost::function<Recording(const Recording&,const Vector_double&,std::map<std::string, double>&)> PluginFunc;
#else
typedef std::function<Recording(const Recording&,const Vector_double&,std::map<std::string, double>&)> PluginFunc;
#endif

struct UserInput {
    std::vector<std::string> labels; 
    Vector_double defaults; 
    std::string title;               


    UserInput(
            const std::vector<std::string>& labels_=std::vector<std::string>(0),
            const Vector_double& defaults_=Vector_double(0),
            std::string title_="\0"
    ) : labels(labels_),defaults(defaults_),title(title_)
    {
                if (defaults.size()!=labels.size()) {
                    defaults.resize(labels.size());
                    std::fill(defaults.begin(), defaults.end(), 0.0);
                }
    }
};


struct Plugin {

    Plugin(
            const wxString& menuEntry_,
            const PluginFunc& pluginFunc_,
            const UserInput& input_=UserInput()
    ) : menuEntry(menuEntry_),pluginFunc(pluginFunc_),input(input_)
    {
        id = n_plugins;
        n_plugins++;
    }
    
    ~Plugin() { }
 
    int id;                
    static int n_plugins;  
    wxString menuEntry;    
    PluginFunc pluginFunc; 
    UserInput input;       
};


struct Extension {

    Extension(const std::string& menuEntry_, void* pyFunc_,
              const std::string& description_, bool requiresFile_) :
        menuEntry(menuEntry_), pyFunc(pyFunc_),
        description(description_), requiresFile(requiresFile_)
    {
        id = n_extensions;
        n_extensions++;
    }
    
    ~Extension() { }
 
    int id;                
    static int n_extensions;  
    std::string menuEntry;    
    void* pyFunc;     
    std::string description;  
    bool requiresFile;     
};

struct ifstreamMan {
    

    ifstreamMan( const wxString& filename )
    : myStream( filename, wxT("r") ) 
    {}
    
    ~ifstreamMan() { myStream.Close(); }
    
    wxFFile myStream;
};

struct ofstreamMan {


    ofstreamMan( const wxString& filename )
    : myStream( filename, wxT("w") ) 
    {}
    
    ~ofstreamMan() { myStream.Close(); }

    wxFFile myStream;
};
 
class Event {
public:
    explicit Event(std::size_t start, std::size_t peak, std::size_t size, wxCheckBox* cb);
    
    ~Event();


    std::size_t GetEventStartIndex() const { return eventStartIndex; }


    std::size_t GetEventPeakIndex() const { return eventPeakIndex; }


    std::size_t GetEventSize() const { return eventSize; }


    bool GetDiscard() const { return !checkBox->GetValue(); }


    wxCheckBox* GetCheckBox() {return checkBox;}


    void SetEventStartIndex( std::size_t value ) { eventStartIndex = value; }


    void SetEventPeakIndex( std::size_t value ) { eventPeakIndex = value; }


    void SetEventSize( std::size_t value ) { eventSize = value; }


    /*void SetDiscard( bool value ) { discard = value; }*/

    /*void ToggleStatus() { discard = !discard; }*/
 
private:
    std::size_t eventStartIndex;
    std::size_t eventPeakIndex;
    std::size_t eventSize;
    wxCheckBox* checkBox;
 
};


struct PyMarker {

    PyMarker( double xv, double yv ) : x(xv), y(yv) {} 
    double x; 
    double y; 
};
 
struct StfDll SectionAttributes {
    SectionAttributes();
    std::vector<stf::Event> eventList;
    std::vector<stf::PyMarker> pyMarkers;
    bool isFitted,isIntegrated;
    stfnum::storedFunc *fitFunc;
    Vector_double bestFitP;
    Vector_double quad_p;
    std::size_t storeFitBeg;
    std::size_t storeFitEnd;
    std::size_t storeIntBeg;
    std::size_t storeIntEnd;
    stfnum::Table bestFit;
};
 
struct SectionPointer {
    SectionPointer(Section* pSec=NULL, const SectionAttributes& sa=SectionAttributes());
    Section* pSection;
    SectionAttributes sec_attr;
};

const double PI=3.14159265358979323846;


int round(double toRound);

enum cursor_type {
    measure_cursor,  
    peak_cursor,     
    base_cursor,     
    decay_cursor,    
    latency_cursor,  
    zoom_cursor,     
    event_cursor,    
    annotation_cursor, 
#ifdef WITH_PSLOPE
    pslope_cursor,   
#endif
    undefined_cursor 
};
 
enum zoom_channels {
    zoomch1, 
    zoomch2, 
    zoomboth 
};

enum latency_mode {
    manualMode = 0,  
    peakMode = 1,    
    riseMode = 2,    
    halfMode = 3,    
    footMode = 4,     
    undefinedMode   
};

enum latency_window_mode {
    defaultMode = 0,   
    windowMode = 1   
};
 
#ifdef WITH_PSLOPE
enum pslope_mode_beg {
    psBeg_manualMode =0,    /*< Set the start Slope cursor manually. */
    psBeg_footMode   =1,    /*< Set the start Slope cursor to the beginning of an event. */
    psBeg_thrMode    =2,    /*< Set the start Slope cursor to a threshold. */
    psBeg_t50Mode    =3,    /*< Set the start Slope cursor to the half-width of an event*/
    psBeg_undefined
};

enum pslope_mode_end {
    psEnd_manualMode =0,    /*< Set the end Slope cursor manually. */
    psEnd_t50Mode    =1,    /*< Set the Slope cursor to the half-width of an event. */
    psEnd_DeltaTMode =2,    /*< Set the Slope cursor to a given distance from the first cursor. */
    psEnd_peakMode   =3,    /*< Set the Slope cursor to the peak. */
    psEnd_undefined
};
 
#endif // WITH_PSLOPE

enum extraction_mode {
    criterion,                 
    correlation,               
    deconvolution               
};

 
} // end of namespace
 
inline int stf::round(double toRound) {
    return toRound <= 0.0 ? int(toRound-0.5) : int(toRound+0.5);
}
 
typedef std::vector< wxString >::iterator       wxs_it;      
typedef std::vector< wxString >::const_iterator c_wxs_it;    
typedef std::vector< stf::Event      >::iterator       event_it;    
typedef std::vector< stf::Event      >::const_iterator c_event_it;  
typedef std::vector< stf::PyMarker   >::iterator       marker_it;   
typedef std::vector< stf::PyMarker   >::const_iterator c_marker_it; 
 
// Doxygen-links to documentation of frequently used wxWidgets-classes



















 






 
#endif