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, startFitAtPeak, initialized, progress;
    Recording Average;
    int InitCursors();
    void PostInit();
    bool ChannelSelDlg();
    void WriteToReg();
    bool outOfRange(std::size_t check) {
        return (check >= cursec().size());
    }
    void Focus();
    void OnNewfromselectedThisMenu( wxCommandEvent& ) { OnNewfromselectedThis( ); }
    void Selectsome(wxCommandEvent& event);
    void Unselectsome(wxCommandEvent& event);
    void SelectTracesOfType(wxCommandEvent& event);
    void UnselectTracesOfType(wxCommandEvent& event);
    void ConcatenateMultiChannel(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& ) { 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;
    stfnum::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; 
    stfnum::baseline_method baselineMethod; // method for calculating baseline
#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;
    bool ShowRuler; // show a ruler throught the measurement cursor?
    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, APMaxRiseY, APMaxRiseT, APt50LeftReal,
        APrtLoHi, APtLoReal, APtHiReal, APt0Real,
#ifdef WITH_PSLOPE
        PSlope,
#endif
        rtLoHi, InnerLoRT, InnerHiRT, OuterLoRT, OuterHiRT, halfDuration, slopeRatio, t0Real;
    // cursor windows:
    int pM;  //peakMean, number of points used for averaging
    int RTFactor; // Lower point for the rise-time calculation
    
    std::size_t tLoIndex, tHiIndex, t50LeftIndex, t50RightIndex, APt50LeftIndex, APt50RightIndex, APtLoIndex, APtHiIndex;
 
    bool fromBase, viewCrosshair,viewBaseline,viewBaseSD,viewThreshold, viewPeakzero,viewPeakbase,viewPeakthreshold,
        viewRTLoHi, viewInnerRiseTime, viewOuterRiseTime,
        viewT50,viewRD,viewSloperise,viewSlopedecay,viewLatency,
        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();
 
#ifndef TEST_MINIMAL

    virtual bool DoSaveDocument(const wxString& filename);
#endif

    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 GetStartFitAtPeak() const { return startFitAtPeak; }


    bool GetPeakAtEnd() const { return peakAtEnd; }


    bool IsInitialized() const { return initialized; }


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


    void SetStartFitAtPeak(bool value) { startFitAtPeak=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 );


    void OnAddAnnotation( wxCommandEvent& WXUNUSED(event) );


    void OnRemoveAnnotation( wxCommandEvent& WXUNUSED(event) );


    void OnEraseAllAnnotations( wxCommandEvent& WXUNUSED(event) );


    void OnExportAnnotations( wxCommandEvent& WXUNUSED(event) );


    void OnImportAnnotations( wxCommandEvent& WXUNUSED(event) );
    

    void OnExpertDetectEvents( wxCommandEvent& WXUNUSED(event) );
 


    bool SubtractBase( );


    void FitDecay(wxCommandEvent& event);


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

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


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


    stfnum::baseline_method GetBaselineMethod() const { return baselineMethod; }


    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 GetInnerLoRT() const { return InnerLoRT; }


    double GetInnerHiRT() const { return InnerHiRT; }


    double GetOuterLoRT() const { return OuterLoRT; }


    double GetOuterHiRT() const { return OuterHiRT; }


    double GetT0Real() const { return t0Real; }


    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 GetAPT0Real() const { return APt0Real; }


    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 GetPeakTime() const { return maxT; }


    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 GetInnerRiseTime() const { return (InnerHiRT-InnerLoRT); }


    double GetOuterRiseTime() const { return (OuterHiRT-OuterLoRT); }


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


    stfnum::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 GetViewInnerRiseTime() const { return viewInnerRiseTime; }


    bool GetViewOuterRiseTime() const { return viewOuterRiseTime; }


    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 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 SetMeasCursor(int value);


    void SetMeasRuler(bool value) { ShowRuler = value; }
    

    bool GetMeasRuler() const { return ShowRuler;}


    void SetBaselineMethod(stfnum::baseline_method value) { baselineMethod = 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(stfnum::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 SetViewInnerRiseTime(bool value) { viewInnerRiseTime=value; }


    void SetViewOuterRiseTime(bool value) { viewOuterRiseTime=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; }
    
    stfnum::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_, stfnum::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);
    bool LoadTDMS(const std::string& filename, Recording& ReturnData);
    
    // calculates the Raw Detection Trace d(t) = d(t-1) + y(t) - 2 y(t-10) + y(t-20)
    std::vector<double> CalcRawDetectionTrace(std::size_t filterOrder, std::size_t startPoint, std::size_t endPoint);
    std::vector<int> CalcScoringTrace(std::vector<Annotation> expertAnnotations, std::size_t startPoint, std::size_t endPoint);
    double CalcAreaUnderCurve(std::vector<double> d, std::vector<int> c);
    std::pair<std::size_t, double> CalcMaxKappa(std::vector<double> &sortedRawDetectionTrace, std::vector<int> &sortedScoringTrace);
    std::vector<double> SortScoringTraceByRawDetection(std::vector<double> &rawDetectionTrace, std::vector<int> &scoringTrace);
    std::vector<stf::Event> DetectEvents(double threshold_, std::vector<double> &rawDetectionTrace);
    void OnCalculatedThresholdExpertDetectEvents(double threshold, std::size_t filterOrder);
 
    DECLARE_EVENT_TABLE()
 
};

 
#endif