src/stimfit/gui/doc.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 _DOC_H
#define _DOC_H

#include "./../stf.h"


class StfDll wxStfDoc: public wxDocument, public Recording
{
#ifndef FROM_PYTHON
    DECLARE_DYNAMIC_CLASS(wxStfDoc)
#endif
private:
    bool peakAtEnd, initialized, progress;
    Recording Average;
    int InitCursors();
    void PostInit();
    bool ChannelSelDlg();
    void WriteToReg();
    bool outOfRange(std::size_t check) {
        return (check>=cur().size());
    }
    void Focus();
    void OnNewfromselectedThisMenu( wxCommandEvent& event ) { OnNewfromselectedThis( ); }
    void Selectsome(wxCommandEvent& event);
    void Unselectsome(wxCommandEvent& event);
    void Concatenate(wxCommandEvent& event);
    void OnAnalysisBatch( wxCommandEvent& event );
    void OnAnalysisIntegrate( wxCommandEvent& event );
    void OnAnalysisDifferentiate( wxCommandEvent& event );
    //void OnSwapChannels( wxCommandEvent& event );
    void Multiply(wxCommandEvent& event);
    void SubtractBaseMenu( wxCommandEvent& event ) { SubtractBase( ); }
    void LFit(wxCommandEvent& event);
    void LnTransform(wxCommandEvent& event);
    void Filter(wxCommandEvent& event);
    void P_over_N(wxCommandEvent& event);
    void Plotextraction(stf::extraction_mode mode);
    void Plotcriterion(wxCommandEvent& event);
    void Plotcorrelation(wxCommandEvent& event);
    void Plotdeconvolution(wxCommandEvent& event);
    void MarkEvents(wxCommandEvent& event);
    void Threshold(wxCommandEvent& event);
    void Viewtable(wxCommandEvent& event);
    void Fileinfo(wxCommandEvent& event);
    Recording ReorderChannels();

    wxMenu* doc_file_menu;


    stf::latency_mode latencyStartMode, latencyEndMode;
    stf::latency_window_mode latencyWindowMode;
    stf::direction      direction; //of peak detection: UP, DOWN or BOTH
#ifdef WITH_PSLOPE
    stf::pslope_mode_beg pslopeBegMode; // for left mode PSlope cursor
    stf::pslope_mode_end pslopeEndMode; // for right mode PSlope cursor
#endif 
    std::size_t baseBeg, baseEnd, peakBeg, peakEnd, fitBeg, fitEnd; 
#ifdef WITH_PSLOPE
    std::size_t PSlopeBeg, PSlopeEnd;
    int DeltaT;  // distance (number of points) from the first cursor
    bool viewPSlope;
#endif
    std::size_t measCursor;
    double latencyStartCursor,
        latencyEndCursor,
        latency,         //time from latency cursor to beginning of event
        base, APBase, baseSD, threshold, slopeForThreshold, peak, APPeak, tLoReal, tHiReal, t50LeftReal, t50RightReal,
        maxT, thrT, maxRiseY, maxRiseT, maxDecayY, maxDecayT, maxRise, maxDecay,
        t50Y, APMaxT, APMaxRise, APMaxRiseT, APt50LeftReal, 
//#ifdef WITH_PSLOPE
        PSlope,
//#endif
        rtLoHi, halfDuration, slopeRatio, t0Real;
    // cursor windows:
    int pM;  //peakMean, number of points used for averaging
    int RTFactor; // Lower point for the rise-time calculation
#ifdef WITH_PSLOPE
#endif

    // currently accessed channel:
    std::size_t cc;
    // second channel:
    std::size_t sc;
    // currently accessed section:
    std::size_t cs;

    // Indices of the selected sections
    std::vector<std::size_t> selectedSections;
    // Base line value for each selected trace
    Vector_double selectBase;
    
    std::size_t tLoIndex, tHiIndex, t50LeftIndex, t50RightIndex, APt50LeftIndex, APt50RightIndex;

    bool fromBase, viewCrosshair,viewBaseline,viewBaseSD,viewThreshold, viewPeakzero,viewPeakbase,viewPeakthreshold, viewRTLoHi,
        viewT50,viewRD,viewSloperise,viewSlopedecay,viewLatency,
#ifdef WITH_PSLOPE
        //viewPSlope,
#endif
        viewCursors;

    XZoom xzoom;
    std::vector<YZoom> yzoom;

    std::vector< std::vector<stf::SectionAttributes> > sec_attr;
    
public:


    wxStfDoc();
    ~wxStfDoc();


    void OnSwapChannels( wxCommandEvent& event );


    virtual bool OnOpenDocument(const wxString& filename);


    virtual bool OnOpenPyDocument(const wxString& filename);


    virtual bool SaveAs();


    virtual bool DoSaveDocument(const wxString& filename);


    virtual bool OnCloseDocument();


    virtual bool OnNewDocument();


    void SetData( const Recording& c_Data, const wxStfDoc* Sender, const wxString& title );


    bool GetIsAverage() const { return !Average.get().empty(); }


    bool GetPeakAtEnd() const { return peakAtEnd; }


    bool IsInitialized() const { return initialized; }


    void SetPeakAtEnd(bool value) { peakAtEnd=value; }


    const Recording& GetAverage() const { return Average; }

    void CheckBoundaries();


    bool SetSection(std::size_t section);


    bool OnNewfromselectedThis( );


    void Selectall(wxCommandEvent& event);


    void Deleteselected(wxCommandEvent& event);

    void UpdateSelectedButton();


    void CreateAverage( bool calcSD, bool align );

#if 0


    void Userdef(std::size_t id);
#endif

    void ToggleSelect( );

    void Select();

    void Remove();


    void Extract(wxCommandEvent& event);


    void InteractiveEraseEvents(wxCommandEvent& event);
    

    void AddEvent( wxCommandEvent& event );


    bool SubtractBase( );


    void FitDecay(wxCommandEvent& event);


    void SetFileMenu( wxMenu* menu ) { doc_file_menu = menu; }
    

    void Measure();
    
    stf::Table CurResultsTable();


    std::size_t GetCurCh() const { return cc; }


    std::size_t GetSecCh() const { return sc; }


    std::size_t GetCurSec() const { return cs; }


    std::size_t GetMeasCursor() const { return measCursor; }


    std::size_t GetBaseBeg() const { return baseBeg; }


    std::size_t GetBaseEnd() const { return baseEnd; }


    std::size_t GetPeakBeg() const { return peakBeg; }


    std::size_t GetPeakEnd() const { return peakEnd; }


    std::size_t GetFitBeg() const { return fitBeg; }


    std::size_t GetFitEnd() const { return fitEnd; }

#ifdef WITH_PSLOPE


    std::size_t GetPSlopeBeg() const { return PSlopeBeg; }


    std::size_t GetPSlopeEnd() const { return PSlopeEnd; }
#endif // WITH_PSLOPE


    int GetPM() const { return pM; }

#ifdef WITH_PSLOPE


    int GetDeltaT() const { return DeltaT; }
#endif


    double GetLatencyBeg() const { return latencyStartCursor; }


    double GetLatencyEnd() const { return latencyEndCursor; }
    

    double GetLatency() const { return latency; }


    double GetTLoReal() const { return tLoReal; }


    double GetTHiReal() const { return tHiReal; }


    double GetT50LeftReal() const { return t50LeftReal; }


    double GetT50RightReal() const { return t50RightReal; }


    double GetT50Y() const { return t50Y; }


    double GetMaxRise() const { return maxRise; }


    double GetMaxDecay() const { return maxDecay; }


    double GetAPMaxRiseT() const { return APMaxRiseT; }


    double GetAPMaxT() const { return APMaxT; }


    double GetAPT50LeftReal() const { return APt50LeftReal; }


    double GetMaxRiseT() const { return maxRiseT; }


    double GetMaxRiseY() const { return maxRiseY; }


    double GetMaxDecayT() const { return maxDecayT; }


    double GetMaxDecayY() const { return maxDecayY; }
    

    double GetMeasValue();
    

    double GetPeak() const { return peak; }
    

    double GetBase() const { return base; }


    double GetAPBase() const { return APBase; }
    

    double GetBaseSD() const { return baseSD; }
    

    double GetThreshold() const { return threshold; }
    

    double GetMaxT() const { return maxT; }
    

    double GetThrT() const { return thrT; }
    

    double GetRTLoHi() const { return rtLoHi; }


    double GetHalfDuration() const { return halfDuration; }

    

    double GetSlopeRatio() const { return slopeRatio; }


    int GetRTFactor() const { return RTFactor; }

//#ifdef WITH_PSLOPE

    double GetPSlope() const { return PSlope; }
//#endif


    stf::latency_mode GetLatencyStartMode() const { return latencyStartMode; }


    stf::latency_mode GetLatencyEndMode() const { return latencyEndMode; }
    

    stf::latency_window_mode GetLatencyWindowMode() const { return latencyWindowMode; }


    stf::direction GetDirection() const { return direction; }
    

#ifdef WITH_PSLOPE


    stf::pslope_mode_beg GetPSlopeBegMode() const { return pslopeBegMode; }


    stf::pslope_mode_end GetPSlopeEndMode() const { return pslopeEndMode; }
#endif // WITH_PSLOPE


    bool GetFromBase() const { return fromBase; }


    bool GetViewCrosshair() const { return viewCrosshair; }


    bool GetViewBaseline() const { return viewBaseline; }


    bool GetViewBaseSD() const { return viewBaseSD; }


    bool GetViewThreshold() const { return viewThreshold; }


    bool GetViewPeakZero() const { return viewPeakzero; }


    bool GetViewPeakBase() const { return viewPeakbase; }


    bool GetViewPeakThreshold() const { return viewPeakthreshold; }


    bool GetViewRTLoHi() const { return viewRTLoHi; }


    bool GetViewT50() const { return viewT50; }


    bool GetViewRD() const { return viewRD; }


    bool GetViewSlopeRise() const { return viewSloperise; }


    bool GetViewSlopeDecay() const { return viewSlopedecay; }


    bool GetViewLatency() const { return viewLatency; }

#ifdef WITH_PSLOPE


    bool GetViewPSlope() const { return viewPSlope; }

#endif


    bool GetViewCursors() const { return viewCursors; }
    

    double GetSlopeForThreshold() const { return slopeForThreshold; }
    

    const std::vector<std::size_t>& GetSelectedSections() const { return selectedSections; } 


    std::vector<std::size_t>& GetSelectedSectionsW() { return selectedSections; } 


    const Vector_double& GetSelectBase() const { return selectBase; } 


    Vector_double& GetSelectBaseW() { return selectBase; }


    const Section& cur() const { return get()[cc][cs]; }


    Section& cur() { return get()[cc][cs]; }


    const Section& sec() const { return get()[sc][cs]; }
    

    const XZoom& GetXZoom() { return xzoom; }


    XZoom& GetXZoomW() { return xzoom; }
        

    const YZoom& GetYZoom(int ch) { return yzoom.at(ch); }


    YZoom& GetYZoomW(int ch) { return yzoom.at(ch); }


    void SetCurCh(std::size_t value);


    void SetSecCh(std::size_t value);


    void SetCurSec(std::size_t value);


    void SelectTrace(std::size_t sectionToSelect);


    bool UnselectTrace(std::size_t sectionToUnselect);


    void SetMeasCursor(int value);


    void SetBaseBeg(int value);


    void SetBaseEnd(int value);


    void SetPeakBeg(int value);


    void SetPeakEnd(int value);


    void SetFitBeg(int value);


    void SetFitEnd(int value);


    void SetLatencyBeg(double value);


    void SetLatencyEnd(double value);


    void SetLatency(double value) { latency=value; }

#ifdef WITH_PSLOPE


    void SetPSlopeBeg(int value);


    void SetPSlopeEnd(int value);


    void SetPSlope(double value) { PSlope=value; }


    void SetPSlopeBegMode(stf::pslope_mode_beg value) { pslopeBegMode=value; }


    void SetPSlopeEndMode(stf::pslope_mode_end value) { pslopeEndMode=value; }


    void SetDeltaT(int value) { DeltaT=value; }

#endif // WITH_PSLOPE


    void SetPM(int value) { pM=value; }


    void SetRTFactor(int value);


    void SetLatencyStartMode(stf::latency_mode value) { latencyStartMode=value; }


    void SetLatencyEndMode(stf::latency_mode value) {
        latencyEndMode=value;
    }


    void SetLatencyWindowMode(stf::latency_window_mode value) {
        latencyWindowMode=value;
    }
    

    void SetLatencyStartMode(int value);


    void SetLatencyEndMode(int value);
    

    void SetLatencyWindowMode(int value);


    void SetDirection(stf::direction value) { direction=value; }


    void SetFromBase(bool frombase) { fromBase = frombase; }
    

    void SetViewCrosshair(bool value) { viewCrosshair=value; }


    void SetViewBaseline(bool value) { viewBaseline=value; }


    void SetViewBaseSD(bool value) { viewBaseSD=value; }


    void SetViewThreshold(bool value) { viewThreshold=value; }


    void SetViewPeakZero(bool value) { viewPeakzero=value; }


    void SetViewPeakBase(bool value) { viewPeakbase=value; }


    void SetViewPeakThreshold(bool value) { viewPeakthreshold=value; }


    void SetViewRTLoHi(bool value) { viewRTLoHi=value; }


    void SetViewT50(bool value) { viewT50=value; }


    void SetViewRD(bool value) { viewRD=value; }


    void SetViewSlopeRise(bool value) { viewSloperise=value; }


    void SetViewSlopeDecay(bool value) { viewSlopedecay=value; }


    void SetViewLatency(bool value) { viewLatency=value; }

#ifdef WITH_PSLOPE


    void SetViewPSlope(bool value) { viewPSlope=value; }
#endif


    void SetViewCursors(bool value) { viewCursors=value; }


    void SetSlopeForThreshold(double value) { slopeForThreshold=value; }
    
    stf::Table CurAsTable() const;
    

    void CopyCursors(const wxStfDoc& c_Recording);


    virtual void resize(std::size_t c_n_channels);


    virtual void InsertChannel(Channel& c_Channel, std::size_t pos);

    const stf::SectionAttributes& GetSectionAttributes(std::size_t nchannel, std::size_t nsection) const;
    const stf::SectionAttributes& GetCurrentSectionAttributes() const;
    stf::SectionAttributes& GetCurrentSectionAttributesW();

    void DeleteFit(std::size_t nchannel, std::size_t nsection);
    

    void SetIsFitted( std::size_t nchannel, std::size_t nsection,
                      const Vector_double& bestFitP_, stf::storedFunc* fitFunc_,
                      double chisqr, std::size_t fitBeg, std::size_t fitEnd );



    void SetIsIntegrated(std::size_t nchannel, std::size_t nsection, bool value,
                         std::size_t begin, std::size_t end, const Vector_double& quad_p_);
    
    void ClearEvents(std::size_t nchannel, std::size_t nsection);

    void correctRangeR(int& value);
    void correctRangeR(std::size_t& value);
    
    DECLARE_EVENT_TABLE()
};

#endif