src/stimfit/stf.h

// 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_

#include <boost/function.hpp>
#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>
    #endif

    #include <wx/wfstream.h>
    #include <wx/progdlg.h>
#else
    typedef std::string wxString;
    typedef int wxWindow;
    #define wxT(x)  x
    #define wxCHECK_VERSION(major,minor,release) 0
#endif

#include "../libstfio/stfio.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);

typedef boost::function<Recording(const Recording&,const Vector_double&,std::map<std::string, double>&)> PluginFunc;


class StfDll Table {
public:

    Table(std::size_t nRows,std::size_t nCols);


    Table(const std::map< std::string, double >& map);


    double at(std::size_t row,std::size_t col) const;


    double& at(std::size_t row,std::size_t col);
    

    bool IsEmpty(std::size_t row,std::size_t col) const;


    void SetEmpty(std::size_t row,std::size_t col,bool value=true);


    void SetRowLabel(std::size_t row,const std::string& label);


    void SetColLabel(std::size_t col,const std::string& label);


    const std::string& GetRowLabel(std::size_t row) const;


    const std::string& GetColLabel(std::size_t col) const;


    std::size_t nRows() const { return rowLabels.size(); }


    std::size_t nCols() const { return colLabels.size(); }
    

    void AppendRows(std::size_t nRows);

private:
    // row major order:
    std::vector< std::vector<double> > values;
    std::vector< std::deque< bool > > empty;
    std::vector< std::string > rowLabels;
    std::vector< std::string > colLabels;
};
 
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, bool discard_ = false) : 
        eventStartIndex(start), eventPeakIndex(peak), eventSize(size), discard(discard_) { }
    
    ~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 discard; }


    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;
    bool discard;
};


struct PyMarker {

    PyMarker( double xv, double yv ) : x(xv), y(yv) {} 
    double x; 
    double y; 
};

struct storedFunc;
 
struct StfDll SectionAttributes {
    SectionAttributes();
    std::vector<stf::Event> eventList;
    std::vector<stf::PyMarker> pyMarkers;
    bool isFitted,isIntegrated;
    stf::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;
    stf::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,    
#ifdef WITH_PSLOPE
    pslope_cursor,   
#endif
    undefined_cursor 
};

 
 
enum direction {
    up,                 
    down,               
    both,               
    undefined_direction 
};
 
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, /*< Set the start Slope cursor manually. */
    psBeg_footMode,   /*< Set the start Slope cursor to the beginning of an event. */
    psBeg_thrMode,    /*< Set the start Slope cursor to a threshold. */
    psBeg_t50Mode,    /*< Set the start Slope cursor to the half-width of an event*/
    psBeg_undefined
};

enum pslope_mode_end {
    psEnd_manualMode, /*< Set the end Slope cursor manually. */
    psEnd_t50Mode,   /*< Set the Slope cursor to the half-width of an event. */
    psEnd_DeltaTMode,  /*< Set the Slope cursor to a given distance from the first cursor. */
    psEnd_peakMode,    /*< 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