コード例 #1
0
    protected override void getData()
    {
        ArrayList dataPre = SqlitePersonSession.SelectCurrentSessionPersons(currentSession.UniqueID,
                                                                            false); //means: do not returnPersonAndPSlist

        data = new ArrayList();

        nonSensitiveRows = new ArrayList();
        int j = 0;              //list of added persons

        foreach (Person p in dataPre)
        {
            ArrayList eSQLarray = SqliteEncoder.Select(
                false, -1, p.UniqueID, currentSession.UniqueID, encoderGI,
                exerciseID, "curve", EncoderSQL.Eccons.ALL,
                false, true);

            int activeCurves = UtilEncoder.GetActiveCurvesNum(eSQLarray);
            int allCurves    = eSQLarray.Count;

            string [] s = { p.UniqueID.ToString(), "", p.Name,
                            //activeCurves.ToString(),
                            allCurves.ToString() };
            data.Add(s);

            if (allCurves == 0)
            {
                nonSensitiveRows.Add(j);
            }

            j++;
        }
    }
コード例 #2
0
    private void writeOptionsFile(int graphWidth, int graphHeight)
    {
        string scriptsPath = UtilEncoder.GetSprintPath();

        if (UtilAll.IsWindows())
        {
            scriptsPath = scriptsPath.Replace("\\", "/");
        }

        System.Globalization.NumberFormatInfo localeInfo = new System.Globalization.NumberFormatInfo();
        localeInfo = System.Globalization.NumberFormatInfo.CurrentInfo;

        string scriptOptions =
            "#scriptsPath\n" + UtilEncoder.GetScriptsPath() + "\n" +
            "#filename\n" + UtilEncoder.GetRaceAnalyzerCSVFileName() + "\n" +
            "#mass\n" + Util.ConvertToPoint(mass) + "\n" +
            "#personHeight\n" + Util.ConvertToPoint(personHeight / 100.0) + "\n" +                         //send it in meters
            "#tempC\n" + tempC + "\n" +
            "#testLength\n" + testLength.ToString() + "\n" +
            "#os\n" + UtilEncoder.OperatingSystemForRGraphs() + "\n" +
            "#graphWidth\n" + graphWidth.ToString() + "\n" +
            "#graphHeight\n" + graphHeight.ToString();


        TextWriter writer = File.CreateText(Path.GetTempPath() + "Roptions.txt");

        writer.Write(scriptOptions);
        writer.Flush();
        writer.Close();
        ((IDisposable)writer).Dispose();
    }
コード例 #3
0
    public static bool CallR(string script)
    {
        string        executable = UtilEncoder.RProcessBinURL();
        List <string> parameters = new List <string>();

        //A) fix script name
        if (UtilAll.IsWindows())
        {
            script = script.Replace("\\", "/");
        }

        parameters.Insert(0, "\"" + script + "\"");

        //B) tempPath
        string tempPath = Path.GetTempPath();

        if (UtilAll.IsWindows())
        {
            tempPath = tempPath.Replace("\\", "/");
        }

        parameters.Insert(1, "\"" + tempPath + "\"");

        LogB.Information("\nCalling R file ----->");

        //C) call process
        //ExecuteProcess.run (executable, parameters);
        Result execute_result = run(executable, parameters, true, true);

        //LogB.Information("Result = " + execute_result.stdout);

        LogB.Information("\n<------ Done calling R file.");
        return(execute_result.success);
    }
コード例 #4
0
    private void writeOptionsFile(int graphWidth, int graphHeight)
    {
        string scriptsPath = UtilEncoder.GetSprintPath();

        if (UtilAll.IsWindows())
        {
            scriptsPath = scriptsPath.Replace("\\", "/");
        }

        System.Globalization.NumberFormatInfo localeInfo = new System.Globalization.NumberFormatInfo();
        localeInfo = System.Globalization.NumberFormatInfo.CurrentInfo;

        string scriptOptions =
            "#os\n" + UtilEncoder.OperatingSystemForRGraphs() + "\n" +
            "#decimalChar\n" + localeInfo.NumberDecimalSeparator + "\n" +
            "#graphWidth\n" + graphWidth.ToString() + "\n" +
            "#graphHeight\n" + graphHeight.ToString() + "\n" +
            "#averageLength\n" + Util.ConvertToPoint(averageLength) + "\n" +
            "#percentChange\n" + Util.ConvertToPoint(percentChange) + "\n" +
            "#vlineT0\n" + Util.BoolToRBool(vlineT0) + "\n" +
            "#vline50fmax.raw\n" + Util.BoolToRBool(vline50fmax_raw) + "\n" +
            "#vline50fmax.fitted\n" + Util.BoolToRBool(vline50fmax_fitted) + "\n" +
            "#hline50fmax.raw\n" + Util.BoolToRBool(hline50fmax_raw) + "\n" +
            "#hline50fmax.fitted\n" + Util.BoolToRBool(hline50fmax_fitted) + "\n" +
            "#RFDs";

        foreach (ForceSensorRFD rfd in rfdList)
        {
            if (rfd.active)
            {
                scriptOptions += "\n" + rfd.ToR();
            }
            else
            {
                scriptOptions += "\n-1";
            }
        }

        if (impulse.active)
        {
            scriptOptions += "\n" + impulse.ToR();
        }
        else
        {
            scriptOptions += "\n-1";
        }

        scriptOptions +=
            "\n#testLength\n" + testLength.ToString() + "\n" +
            "#title\n" + title + "\n" +
            "#scriptsPath\n" + UtilEncoder.GetScriptsPath() + "\n";

        TextWriter writer = File.CreateText(Path.GetTempPath() + "Roptions.txt");

        writer.Write(scriptOptions);
        writer.Flush();
        writer.Close();
        ((IDisposable)writer).Dispose();
    }
コード例 #5
0
    void runEncoderAnalyzeOpenImage()
    {
        string imagePath = UtilEncoder.GetSprintEncoderImage();

        image_race_encoder_graph = UtilGtk.OpenImageSafe(
            imagePath,
            image_race_encoder_graph);
    }
コード例 #6
0
 //copy export from temp file to the file that user has selected
 private void copyExportedFile()
 {
     //wait first this status mark that is created when file is fully exported
     while (!Util.FileExists(UtilEncoder.GetEncoderStatusTempBaseFileName() + "6.txt"))
     {
         ;
     }
     //copy the file
     File.Copy(es.OutputData1, ExportFileName, true);
 }
コード例 #7
0
 private void on_button_runs_sprint_save_image_selected(string destination)
 {
     try {
         File.Copy(UtilEncoder.GetSprintImage(), destination, true);
     } catch {
         string myString = string.Format(
             Catalog.GetString("Cannot save file {0} "), destination);
         new DialogMessage(Constants.MessageTypes.WARNING, myString);
     }
 }
コード例 #8
0
    private void initializeList(Constants.EncoderType type, bool inertial, bool rotaryFrictionOnAxis, int position)
    {
        check_rotary_friction_inertia_on_axis_is_visible();

        list = UtilEncoder.EncoderConfigurationList(type, inertial, rotaryFrictionOnAxis);

        listCurrent = position;         //current item on list

        buttons_previous_next_sensitive();
        selectedModeChanged();
    }
コード例 #9
0
    //TODO: do all this with an "other" thread like in force sensor to allow connecting messages to be displayed
    private bool runEncoderCapturePre()
    {
        if (!portREOpened)
        {
            if (!runEncoderConnect())
            {
                return(false);
            }
        }

        if (File.Exists(UtilEncoder.GetSprintEncoderImage()))
        {
            Util.FileDelete(UtilEncoder.GetSprintEncoderImage());
        }

        event_execute_label_message.Text = "Please, wait ...";
        captureEndedMessage = "";
        capturingRunEncoder = arduinoCaptureStatus.STARTING;

        button_execute_test.Sensitive         = false;
        event_execute_button_finish.Sensitive = true;
        event_execute_button_cancel.Sensitive = true;

        //forceCaptureStartMark = false;

        runEncoderProcessFinish = false;
        runEncoderProcessCancel = false;
        runEncoderProcessError  = false;

        //To know if USB has been disconnected
        usbDisconnectedCount    = 0;
        usbDisconnectedLastTime = 0;

        /*
         * //initialize
         * forceSensorValues = new ForceSensorValues();
         */

        event_execute_ButtonFinish.Clicked -= new EventHandler(on_finish_clicked);
        event_execute_ButtonFinish.Clicked += new EventHandler(on_finish_clicked);

        event_execute_ButtonCancel.Clicked -= new EventHandler(on_cancel_clicked);
        event_execute_ButtonCancel.Clicked += new EventHandler(on_cancel_clicked);

        event_execute_label_message.Text = "Capturing ...";

        runEncoderCaptureThread = new Thread(new ThreadStart(runEncoderCaptureDo));
        GLib.Idle.Add(new GLib.IdleHandler(pulseGTKRunEncoderCapture));

        LogB.ThreadStart();
        runEncoderCaptureThread.Start();
        return(true);
    }
コード例 #10
0
    private bool on_button_sprint_do()
    {
        button_sprint_save_image.Sensitive = false;
        if (currentPersonSession.Weight == 0)
        {
            new DialogMessage(Constants.MessageTypes.WARNING,
                              Catalog.GetString("Error, weight of the person cannot be 0"));
            return(false);
        }

        if (currentPersonSession.Height == 0)
        {
            new DialogMessage(Constants.MessageTypes.WARNING,
                              Catalog.GetString("Error, height of the person cannot be 0"));
            return(false);
        }

        if (!sprint.IsDataOk())
        {
            new DialogMessage(Constants.MessageTypes.WARNING,
                              Catalog.GetString("This data does not seem a sprint.") + "\n\n" +
                              sprint.ErrorMessage);
            return(false);
        }

        Util.FileDelete(UtilEncoder.GetSprintImage());

        image_sprint.Sensitive = false;

        bool success = sprint.CallR(
            viewport_sprint.Allocation.Width - 5,
            viewport_sprint.Allocation.Height - 5,
            currentPerson.Name);

        if (!success)
        {
            new DialogMessage(Constants.MessageTypes.WARNING, Catalog.GetString("This data does not seem a sprint."));
            return(false);
        }

        while (!Util.FileReadable(UtilEncoder.GetSprintImage()))
        {
            ;
        }

        image_sprint = UtilGtk.OpenImageSafe(
            UtilEncoder.GetSprintImage(),
            image_sprint);
        image_sprint.Sensitive             = true;
        button_sprint_save_image.Sensitive = true;
        return(true);
    }
コード例 #11
0
    protected override bool startProcess()
    {
        //If output file is not given, R will try to write in the running folder
        //in which we may haven't got permissions

        string pBin = pBinURL();

        pinfo = new ProcessStartInfo();

        //on Windows we need the \"str\" to call without problems in path with spaces
        //pinfo.Arguments = "\"" + "passToR.R" + "\" " + optionsFile;
        pinfo.Arguments = "\"" + UtilEncoder.GetEncoderScriptCallCaptureNoRdotNet() + "\" " + optionsFile;

        LogB.Information("Arguments:", pinfo.Arguments);
        LogB.Information("--- 1 --- " + optionsFile.ToString() + " ---");
        LogB.Information("--- 2 --- " + pinfo.Arguments.ToString() + " ---");

        pinfo.FileName = pBin;

        pinfo.CreateNoWindow        = true;
        pinfo.UseShellExecute       = false;
        pinfo.RedirectStandardInput = true;
        pinfo.RedirectStandardError = true;
        //pinfo.RedirectStandardOutput = true;


        try {
            p           = new Process();
            p.StartInfo = pinfo;

            p.ErrorDataReceived += new DataReceivedEventHandler(readingError);

            p.Start();

            // Start asynchronous read of the output.
            // Caution: This has to be called after Start
            //p.BeginOutputReadLine();
            p.BeginErrorReadLine();


            LogB.Debug("D");

            LogB.Debug(string.Format("this pid id : {0}", p.Id));
        } catch {
            Console.WriteLine("catched at runEncoderCaptureNoRDotNetStart");
            return(false);
        }

        return(true);
    }
コード例 #12
0
    protected override void writeOptionsFile()
    {
        optionsFile = Path.GetTempPath() + "Roptions.txt";

        string scriptOptions = UtilEncoder.PrepareEncoderGraphOptions(
            "none",                     //title
            es,
            false,                      //neuromuscularProfile
            false,                      //translate (graphs)
            Debug,
            false                       //crossValidate (unactive on capture at the moment)
            ).ToString();

        TextWriter writer = File.CreateText(optionsFile);

        writer.Write(scriptOptions);
        writer.Flush();
        writer.Close();
        ((IDisposable)writer).Dispose();
    }
コード例 #13
0
    protected override void writeOptionsFile()
    {
        optionsFile = Path.GetTempPath() + "Roptions.txt";

        string scriptOptions = UtilEncoder.PrepareEncoderGraphOptions(
            title,
            es,
            neuromuscularProfileDo,
            translate,
            Debug,
            CrossValidate
            ).ToString();

        TextWriter writer = File.CreateText(optionsFile);

        writer.Write(scriptOptions);
        writer.Flush();
        writer.Close();
        ((IDisposable)writer).Dispose();
    }
コード例 #14
0
    protected override void writeOptionsFile()
    {
        optionsFile = Path.GetTempPath() + "Roptions.txt";

        string scriptOptions = UtilEncoder.PrepareEncoderGraphOptions(
            "none",                     //title
            es,
            false,                      //neuromuscularProfile
            false,                      //translate (graphs)
            Debug,
            false,                      //crossValidate (unactive on capture at the moment)
            (CutByTriggers != Preferences.TriggerTypes.NO_TRIGGERS),
            printTriggers(),
            false,                      //separateSessionInDays (false at capture)
            EncoderGraphROptions.AnalysisModes.CAPTURE).ToString();

        TextWriter writer = File.CreateText(optionsFile);

        writer.Write(scriptOptions);
        writer.Flush();
        writer.Close();
        ((IDisposable)writer).Dispose();
    }
コード例 #15
0
ファイル: sprint.cs プロジェクト: davidfombella/chronojump
    private void writeOptionsFile(int graphWidth, int graphHeight, string personName)
    {
        /*
         * string scriptOptions =
         *      "#positions\n" +    "0;20;40;70" + "\n" +
         *      "#splitTimes\n" +   "0;2.73;4.49;6.95" + "\n" +
         *      "#mass\n" +         "75" + "\n" +
         *      "#personHeight\n" +     "1.65" + "\n" +
         *      "#tempC\n" +        "25" + "\n";
         */
        string scriptsPath = UtilEncoder.GetSprintPath();

        if (UtilAll.IsWindows())
        {
            scriptsPath = scriptsPath.Replace("\\", "/");
        }

        string scriptOptions =
            "#scriptsPath\n" + scriptsPath + "\n" +
            "#positions\n" + positions + "\n" +
            "#splitTimes\n" + splitTimes + "\n" +
            "#mass\n" + Util.ConvertToPoint(mass) + "\n" +
            "#personHeight\n" + Util.ConvertToPoint(personHeight / 100.0) + "\n" +                 //send it in meters
            "#tempC\n" + tempC + "\n" +
            "#os\n" + UtilEncoder.OperatingSystemForRGraphs() + "\n" +
            "#graphWidth\n" + graphWidth.ToString() + "\n" +
            "#graphHeight\n" + graphHeight.ToString() + "\n" +
            "#personName\n" + personName + "\n";

        TextWriter writer = File.CreateText(Path.GetTempPath() + "Roptions.txt");

        writer.Write(scriptOptions);
        writer.Flush();
        writer.Close();
        ((IDisposable)writer).Dispose();
    }
コード例 #16
0
 public bool CallR(int graphWidth, int graphHeight)
 {
     LogB.Information("\nforceSensor CallR ----->");
     writeOptionsFile(graphWidth, graphHeight);
     return(ExecuteProcess.CallR(UtilEncoder.GetmifScript()));
 }
コード例 #17
0
    public bool Capture(string outputData1, EncoderRProcCapture encoderRProcCapture,
                        bool compujump, Preferences.TriggerTypes cutByTriggers, double restClustersSeconds, bool playSoundsFromFile)
    {
        /*
         * removed at 1.7.0
         * if(simulated) {
         *      bool success = initSimulated();
         *      if(! success)
         *              return false;
         * }
         */

        lastTriggerOn = 0;
        inertialCalibratedFirstCross0Pos = 0;

        //only for cutByTriggers == Preferences.TriggerTypes.START_AT_FIRST_ON
        bool firstTriggerHappened = false;

        //playSoundsFromFile
        DateTime lastTriggeredSound = DateTime.MinValue;

        if (capturingInertialBG)
        {
            /*
             * reset capture list. If not done here, list will grow at each set
             * also this fixes the initial 0s after a set
             */
            EncoderCaptureInertialBackgroundStatic.Initialize();
        }

        do
        {
            //1 read data
            try {
                byteReaded = readByte();
            } catch {
                if (!simulated)
                {
                    LogB.Error("Maybe encoder cable is disconnected");
                    cancel = true;
                }

                break;
            }

            //2 check if readed data is a trigger
            if (byteReaded == TRIGGER_ON)
            {
                if (playSoundsFromFile)
                {
                    TimeSpan ts = DateTime.Now.Subtract(lastTriggeredSound);
                    if (ts.TotalMilliseconds > 50)
                    {
                        Util.NextSongInList();
                        lastTriggeredSound = DateTime.Now;
                    }

                    continue;
                }

                Trigger trigger = new Trigger(Trigger.Modes.ENCODER, i, true);
                if (triggerList.IsSpurious(trigger))
                {
                    triggerList.RemoveLastOff();
                    continue;
                }

                //TriggerTypes.START_AT_FIRST_ON starts capture at first trigger. So when this happens, reset capture
                if (cutByTriggers == Preferences.TriggerTypes.START_AT_FIRST_ON && !firstTriggerHappened)
                {
                    LogB.Information("Cleaning on capture");

                    startCaptureFromHere();

                    firstTriggerHappened = true;
                    i = -1;                     //will be 0 on next loop start
                    continue;
                }

                if (cutByTriggers != Preferences.TriggerTypes.NO_TRIGGERS)
                {
                    ecc           = new EncoderCaptureCurve(lastTriggerOn, i);
                    lastTriggerOn = i;

                    double [] curve = new double[ecc.endFrame - ecc.startFrame];
                    //int mySum = 0;
                    for (int k = 0, j = ecc.startFrame; j < ecc.endFrame; j++)
                    {
                        curve[k] = encoderReaded[j];
                        k++;
                        //mySum += encoderReaded[j];
                    }
                    //ecc.up = (mySum >= 0);
                    ecc.up = true;                     //make all concentric for the swimming application
                    LogB.Debug("curve stuff" + ecc.startFrame + ":" + ecc.endFrame + ":" + encoderReaded.Count);

                    bool success = encoderRProcCapture.SendCurve(
                        ecc.startFrame,
                        UtilEncoder.CompressData(curve, 25)                                     //compressed
                        );
                    if (!success)
                    {
                        cancel = true;
                    }

                    Ecca.curvesAccepted++;
                    Ecca.ecc.Add(ecc);
                    LogB.Information(ecc.ToString());
                }
                triggerList.Add(trigger);
                continue;
            }
            else if (byteReaded == TRIGGER_OFF)
            {
                if (!playSoundsFromFile)
                {
                    Trigger trigger = new Trigger(Trigger.Modes.ENCODER, i, false);
                    triggerList.Add(trigger);
                }

                continue;
            }

            //3 if is not trigger: convertByte
            byteReaded = convertByte(byteReaded);
            //LogB.Information(" byte: " + byteReaded);

            i = i + 1;
            if (i >= 0)
            {
                if (cont)
                {
                    recordedTimeCont++;
                }

                if (byteReaded == 0)
                {
                    consecutiveZeros++;

                    //clean variables when we are on cont and long time elapsed
                    if (cont && Ecca.curvesAccepted == 0 && consecutiveZeros >= consecutiveZerosMax)
                    {
                        LogB.Information("Cleaning on capture");

                        //remove this time on existing trigger records
                        triggerList.Substract(consecutiveZeros);

                        startCaptureFromHere();

                        i = -1;                         //will be 0 on next loop start
                        continue;
                    }
                }
                else
                {
                    consecutiveZeros = -1;
                }

                //stop if n seconds of inactivity
                //but it has to be moved a little bit first, just to give time to the people
                //if(consecutiveZeros >= consecutiveZerosMax && sum > 0) #Not OK because sum maybe is 0: +1,+1,-1,-1
                //if(consecutiveZeros >= consecutiveZerosMax && ecca.ecc.Count > 0) #Not ok because when ecca is created, ecc.Count == 1

                /*
                 * process ends
                 * (
                 * when a curve has been found and then there are n seconds of inactivity, or
                 * when not in cont and a curve has not been found and then there are 2*n seconds of inactivity
                 * ) and if consecutiveZeros > restClustersSeconds * 1.500
                 *
                 * 1500 is conversion to milliseconds and * 1.5 to have enough time to move after clusters res
                 */
                if (
                    automaticallyEndByTime &&
                    (
                        (Ecca.curvesAccepted > 0 && consecutiveZeros >= consecutiveZerosMax) ||
                        (!cont && Ecca.curvesAccepted == 0 && consecutiveZeros >= (2 * consecutiveZerosMax))
                    ) &&
                    (restClustersSeconds == 0 || consecutiveZeros > restClustersSeconds * 1500)
                    )
                {
                    finish = true;
                    LogB.Information("SHOULD FINISH");
                }


                //on inertialCalibrated set mark where 0 is crossed for the first time
                if (inertialCalibrated && inertialCalibratedFirstCross0Pos == 0)
                {
                    if ((sumInertialDisc <= 0 && sumInertialDisc + byteReaded > 0) ||
                        (sumInertialDisc >= 0 && sumInertialDisc + byteReaded < 0))
                    {
                        inertialCalibratedFirstCross0Pos = i;
                    }
                }

                sumInertialDisc += byteReaded;
                encoderReadedInertialDisc.Add(byteReaded);

                if (inertialCalibrated && sumInertialDisc > 0)
                {
                    byteReaded *= -1;
                }

                sum += byteReaded;
                encoderReaded.Add(byteReaded);


                if (!showOnlyBars)
                {
                    assignEncoderCapturePoints();

                    EncoderCapturePointsCaptured = i;
                }

                if (!showOnlyBars)
                {
                    encoderCapturePointsAdaptativeDisplay();
                }

                // ---- prepare to send to R ----

                //if string goes up or down, store the direction
                //direction is only up or down
                if (byteReaded != 0)
                {
                    directionNow = (int)byteReaded / (int)Math.Abs(byteReaded);                       //1 (up) or -1 (down)
                }
                //if we don't have changed the direction, store the last non-zero that we can find
                if (directionChangeCount == 0 && directionNow == directionLastMSecond)
                {
                    //check which is the last non-zero value
                    //this is suitable to find where starts the only-zeros previous to the change
                    if (byteReaded != 0)
                    {
                        lastNonZero = i;
                    }
                }

                bool sendCurveMaybe = false;

                //if it's different than the last direction, mark the start of change
                if (directionNow != directionLastMSecond)
                {
                    directionLastMSecond = directionNow;
                    directionChangeCount = 0;
                }
                else if (directionNow != directionCompleted)
                {
                    //we are in a different direction than the last completed

                    //we cannot add byteReaded because then is difficult to come back n frames to know the max point
                    //directionChangeCount += byteReaded
                    directionChangeCount++;

                    if (directionChangeCount > directionChangePeriod)                           //count >= than change_period
                    {
                        sendCurveMaybe = true;
                    }
                }

                /*
                 * on inertialCalibrated don't send curve until 0 is crossed
                 * this ensures first stored phase will be ecc, that's what the rest of the program is expecting
                 * TODO: maybe this can be problematic with triggers maybe can be desinchronized, just move values
                 */
                if (inertialCalibrated && inertialCalibratedFirstCross0Pos == 0)
                {
                    sendCurveMaybe = false;
                }

                //if cutByTriggers, triggers send the curve at the beginning of this method
                if (cutByTriggers != Preferences.TriggerTypes.NO_TRIGGERS)
                {
                    sendCurveMaybe = false;
                }

                if (sendCurveMaybe)
                {
                    //int startFrame = previousFrameChange - directionChangeCount;	//startFrame

                    /*
                     * at startFrame we do the "-directionChangePeriod" because
                     * we want data a little bit earlier, because we want some zeros
                     * that will be removed by reduceCurveBySpeed
                     * if not done, then the data:
                     * 0 0 0 0 0 0 0 0 0 1
                     * will start at 10th digit (the 1)
                     * if done, then at speed will be like this:
                     * 0 0 0 0.01 0.04 0.06 0.07 0.08 0.09 1
                     * and will start at fourth digit
                     */

                    //this is better, takes a lot of time before, and then reduceCurveBySpeed will cut it
                    //but reduceCurveBySpeed is not implemented on inertial
                    //TODO: implement it
                    int startFrame = previousEnd;                       //startFrame
                    LogB.Debug("startFrame", startFrame.ToString());
                    if (startFrame < 0)
                    {
                        startFrame = 0;
                    }

                    //on inertial start when crossing 0 first time
                    if (inertialCalibrated && startFrame < inertialCalibratedFirstCross0Pos)
                    {
                        startFrame = inertialCalibratedFirstCross0Pos;
                    }

                    LogB.Information("TTTT - i," + i.ToString() +
                                     "; directionChangeCount: " +
                                     directionChangeCount.ToString() +
                                     "; lastNonZero: " +
                                     lastNonZero.ToString() +
                                     "; final: " +
                                     ((i - directionChangeCount + lastNonZero) / 2).ToString());

                    ecc = new EncoderCaptureCurve(
                        startFrame,
                        (i - directionChangeCount + lastNonZero) / 2                                    //endFrame
                        //to find endFrame, first substract directionChangePeriod from i
                        //then find the middle point between that and lastNonZero
                        //this means that the end is in central point at displacements == 0
                        );

                    //since 1.5.0 secundary thread is capturing and sending data to R process
                    //while main thread is reading data coming from R and updating GUI

                    LogB.Debug("curve stuff" + ecc.startFrame + ":" + ecc.endFrame + ":" + encoderReaded.Count);
                    if (ecc.endFrame - ecc.startFrame > 0)
                    {
                        double [] curve = new double[ecc.endFrame - ecc.startFrame];
                        int       mySum = 0;
                        for (int k = 0, j = ecc.startFrame; j < ecc.endFrame; j++)
                        {
                            curve[k] = encoderReaded[j];
                            k++;
                            mySum += encoderReaded[j];
                        }
                        ecc.up = (mySum >= 0);

                        previousEnd = ecc.endFrame;

                        //22-may-2015: This is done in R now

                        //1) check heightCurve in a fast way first to discard curves soon
                        //   only process curves with height >= min_height
                        //2) if it's concentric, only take the concentric curves,
                        //   but if it's concentric and inertial: take both.
                        //
                        //   When capturing on inertial, we have the first graph
                        //   that will be converted to the second.
                        //   we need the eccentric phase in order to detect the Ci2

                        /*
                         *             /\
                         *            /  \
                         *           /    \
                         *____      C1     \      ___
                         *    \    /        \    /
                         *     \  /          \  C2
                         *      \/            \/
                         *
                         * C1, C2: two concentric phases
                         */

                        /*
                         *____                    ___
                         *    \    /\      /\    /
                         *     \ Ci1 \   Ci2 \ Ci3
                         *      \/    \  /    \/
                         *             \/
                         *
                         * Ci1, Ci2, Ci3: three concentric phases on inertial
                         *
                         * Since 1.6.1:
                         * on inertial curve is sent when rope is fully extended,
                         * this will allow to see at the moment c or e. Not wait the change of direction to see both
                         */


                        //store in a boolean to not call shouldSendCurve() two times because it changes some variables
                        bool shouldSendCurveBool = shouldSendCurve();
                        if (shouldSendCurveBool)
                        {
                            //if compujump, wakeup screen if it's off
                            //do it on the first repetition because it will not be sleeping on the rest of repetitions
                            if (compujump && Ecca.curvesAccepted == 0)
                            {
                                Networks.WakeUpRaspberryIfNeeded();
                            }

                            bool success = encoderRProcCapture.SendCurve(
                                ecc.startFrame,
                                UtilEncoder.CompressData(curve, 25)                                             //compressed
                                );
                            if (!success)
                            {
                                cancel = true;
                            }

                            Ecca.curvesAccepted++;
                            Ecca.ecc.Add(ecc);
                            LogB.Information(ecc.ToString());

                            lastDirectionStoredIsUp = ecc.up;
                        }
                    }

                    //on inertial is different
                    markDirectionChanged();
                }

                //this is for visual feedback of remaining time
                msCount++;
                if (msCount >= 1000)
                {
                    Countdown--;
                    msCount = 1;
                }
            }
        } while ((cont || i < (recordingTime - 1)) && !cancel && !finish);

        LogB.Debug("runEncoderCaptureCsharp main bucle end");

        //leave some time to capture.R be able to paint data, and to create two Roptions.txt file correctly
        if (simulated)
        {
            System.Threading.Thread.Sleep(2000);
        }
        else if (!capturingInertialBG)
        {
            sp.Close();
        }

        if (cancel)
        {
            return(false);
        }

        saveToFile(outputData1);

        LogB.Debug("runEncoderCaptureCsharp ended");

        return(true);
    }
コード例 #18
0
    //non GTK on this method
    private void runEncoderCaptureDo()
    {
        LogB.Information("runEncoderCaptureDo 0");
        lastChangedTime = 0;

        if (!runEncoderSendCommand("start_capture:", "", "Catched run encoder capturing"))
        {
            runEncoderProcessError = true;
            return;
        }

        string str = "";

        LogB.Information("runEncoderCaptureDo 1");
        do
        {
            Thread.Sleep(100);             //sleep to let arduino start reading
            try {
                str = portRE.ReadLine();
            } catch {
                runEncoderProcessError = true;
                return;
            }

            LogB.Information("init string: " + str);
        }while(!str.Contains("Starting capture"));

        //forceCaptureStartMark = true;
        capturingRunEncoder = arduinoCaptureStatus.CAPTURING;

        Util.CreateRaceAnalyzerSessionDirIfNeeded(currentSession.UniqueID);

        string nameDate = currentPerson.Name + "_" + UtilDate.ToFile(DateTime.Now);

        //fileName to save the csv
        string fileName = Util.GetRaceAnalyzerSessionDir(currentSession.UniqueID) + Path.DirectorySeparatorChar + nameDate + ".csv";

        //lastRunEncoderFile to save the images
        lastRunEncoderFile = nameDate;


        TextWriter writer = File.CreateText(fileName);

        writer.WriteLine("Pulses;Time(useconds);Force(N)");
        str = "";
        int firstTime = 0;

        while (!runEncoderProcessFinish && !runEncoderProcessCancel && !runEncoderProcessError)
        {
            //LogB.Information(string.Format("finish conditions: {0}-{1}-{2}",
            //			runEncoderProcessFinish, runEncoderProcessCancel, runEncoderProcessError));

            /*
             * The difference between forceSensor and runEncoder is:
             * runEncoder is not always returning data
             * if user press "finish" button, and they don't move the encoder,
             * this will never end:
             * //str = portRE.ReadLine();
             * so use the following method that allows to return a "" when there no data
             * and then the while above will end with the runEncoderProcessFinish condition
             */
            str = readFromRunEncoderIfDataArrived();
            //LogB.Information("str: " + str); //TODO: remove this log
            if (str == "")
            {
                continue;
            }

            //check if there is one and only one ';'
            //if( ! (str.Contains(";") && str.IndexOf(";") == str.LastIndexOf(";")) )

            string [] strFull = str.Split(new char[] { ';' });
            LogB.Information("captured str: " + str);

            if (strFull.Length != 3)
            {
                continue;
            }

            LogB.Information("pulses: " + strFull[0]);
            if (!Util.IsNumber(strFull[0], false))
            {
                continue;
            }

            LogB.Information("time microseconds: " + strFull[1]);
            if (!Util.IsNumber(strFull[1], false))
            {
                continue;
            }

            LogB.Information("force avg (N): " + strFull[1]);
            if (!Util.IsNumber(strFull[2], false))
            {
                continue;
            }

            /*
             * int time = Convert.ToInt32(strFull[0]);
             *
             * //measurement does not start at 0 time. When we start receiving data, mark this as firstTime
             * if(firstTime == 0)
             *      firstTime = time;
             *
             * //use this to have time starting at 0
             * time -= firstTime;
             *
             * double force = Convert.ToDouble(Util.ChangeDecimalSeparator(strFull[1]));
             */
            int pulse = Convert.ToInt32(strFull[0]);
            int time  = Convert.ToInt32(strFull[1]);
            int force = Convert.ToInt32(strFull[2]);
            writer.WriteLine(pulse.ToString() + ";" + time.ToString() + ";" + force.ToString());
        }
        LogB.Information(string.Format("FINISHED WITH conditions: {0}-{1}-{2}",
                                       runEncoderProcessFinish, runEncoderProcessCancel, runEncoderProcessError));
        LogB.Information("Calling end_capture");
        if (!runEncoderSendCommand("end_capture:", "Ending capture ...", "Catched ending capture"))
        {
            runEncoderProcessError = true;
            capturingRunEncoder    = arduinoCaptureStatus.STOP;
            Util.FileDelete(fileName);
            return;
        }

        LogB.Information("Waiting end_capture");
        do
        {
            Thread.Sleep(10);
            try {
                str = portRE.ReadLine();
            } catch {
                LogB.Information("Catched waiting end_capture feedback");
            }
            LogB.Information("waiting \"Capture ended\" string: " + str);
        }while(!str.Contains("Capture ended"));
        LogB.Information("Success: received end_capture");

        writer.Flush();
        writer.Close();
        ((IDisposable)writer).Dispose();
        capturingRunEncoder = arduinoCaptureStatus.STOP;

        //port.Close();

        if (runEncoderProcessCancel || runEncoderProcessError)
        {
            Util.FileDelete(fileName);
        }
        else
        {
            //call graph. Prepare data
            File.Copy(fileName, UtilEncoder.GetRaceAnalyzerCSVFileName(), true);             //can be overwritten
            lastRunEncoderFullPath = fileName;

            race_analyzer_distance    = Convert.ToInt32(race_analyzer_spinbutton_distance.Value);
            race_analyzer_temperature = Convert.ToInt32(race_analyzer_spinbutton_temperature.Value);
            //create graph
            RunEncoderGraph reg = new RunEncoderGraph(
                race_analyzer_distance,
                currentPersonSession.Weight,                            //TODO: can be more if extra weight
                currentPersonSession.Height,
                race_analyzer_temperature);
            reg.CallR(1699, 768);                                       //TODO: hardcoded

            DateTime runEncoderGraphStarted = DateTime.Now;
            //TODO: check better if png is saved and have a cancel button

            while (!File.Exists(UtilEncoder.GetSprintEncoderImage()) && DateTime.Now.Subtract(runEncoderGraphStarted).TotalSeconds < 5)
            {
                Thread.Sleep(500);
            }

            captureEndedMessage = "Data on raceAnalyzer folder";
            if (File.Exists(UtilEncoder.GetSprintEncoderImage()))
            {
                LogB.Information("File exists on png, trying to copy");
                try {
                    File.Copy(UtilEncoder.GetSprintEncoderImage(),
                              Util.GetRaceAnalyzerSessionDir(currentSession.UniqueID) + Path.DirectorySeparatorChar +
                              lastRunEncoderFile +             //nameDate
                              ".png",
                              true);                           //can be overwritten
                    captureEndedMessage += " (png too)";
                } catch {
                    LogB.Information("Couldn't copy the file");
                    captureEndedMessage += " (Created png but only on tmp folder, could not copy file)";
                }
            }
            else
            {
                LogB.Information("File does not exist on png (after 5 seconds)");
                captureEndedMessage += " (png not created, problem doing the graph)";
            }

            capturingRunEncoder = arduinoCaptureStatus.COPIED_TO_TMP;
        }
    }
コード例 #19
0
    protected void sqliteThings()
    {
        configChronojump = new Config();
        configChronojump.Read();

        bool badExit = checkIfChronojumpExitAbnormally();

        if (badExit)
        {
            if (chronojumpIsExecutingNTimes())
            {
                messageToShowOnBoot += Catalog.GetString("Chronojump is already running") + "\n\n" +
                                       Catalog.GetString("Chronojump will exit now.");

                chronojumpHasToExit = true;
                quitNowCjTwoTimes   = true;
                LogB.Error("Chronojump is already running.");

                return;
            }
            else
            {
                chronojumpCrashedBefore();
            }
        }

        //print version of chronojump
        progVersion = BuildInfo.chronojumpVersion;

        LogB.Information("Chronojump version: {0}", progVersion);

        //to store user videos and photos
        Util.CreateMultimediaDirsIfNeeded();

        //to store (encoder, force sensor, run encoder) data and graphs
        UtilEncoder.CreateEncoderDirIfNeeded();
        Util.CreateForceSensorDirIfNeeded();
        Util.CreateRaceAnalyzerDirIfNeeded();

//TODO: when a session is deleted, encoder data has to be deleted, also multimedia videos, I suppose. Show message to user warning about it
//TODO: encoder weight auto written depending on person loaded, and changes if it changes person or weight


        //move database to new location if chronojump version is before 0.7
        moveDatabaseToNewLocationIfNeeded();

        LogB.Information("move? ended");

        splashMessageChange(1);          //checking database

        /*
         * splashMessage = "pre-connect";
         * needUpdateSplashMessage = true;
         * Console.ReadLine();
         */

        Sqlite.CreateDir();
        bool defaultDBLocation = Sqlite.Connect();

        LogB.SQL("sqlite connected");

        /*
         * splashMessage = "post-connect" + defaultDBLocation.ToString();
         * needUpdateSplashMessage = true;
         * Console.ReadLine();
         */

        //Chech if the DB file exists
        if (!Sqlite.CheckTables(defaultDBLocation))
        {
            LogB.SQL(Catalog.GetString("no tables, creating ..."));

            creatingDB = true;
            splashMessageChange(2);              //creating database



            /*
             * splashMessage = "pre-create";
             * needUpdateSplashMessage = true;
             * Console.ReadLine();
             */



            Sqlite.CreateDir();
            Sqlite.CreateFile();
            //Sqlite.CreateFile(defaultDBLocation);



            /*
             * splashMessage = "post-create";
             * needUpdateSplashMessage = true;
             * Console.ReadLine();
             */



            createRunningFileName(runningFileName);
            Sqlite.CreateTables(false);             //not server
            creatingDB = false;
        }
        else
        {
            LogB.SQL("doing backup");
            //backup the database
            Util.BackupDirCreateIfNeeded();

            splashMessageChange(3);              //making db backup

            Util.BackupDatabase();
            LogB.SQL("made a database backup");              //not compressed yet, it seems System.IO.Compression.DeflateStream and
            //System.IO.Compression.GZipStream are not in mono


            if (!Sqlite.IsSqlite3())
            {
                bool ok = Sqlite.ConvertFromSqlite2To3();
                if (!ok)
                {
                    LogB.Error("problem with sqlite");
                    //check (spanish)
                    //http://mail.gnome.org/archives/chronojump-devel-list/2008-March/msg00011.html
                    string errorMessage = Catalog.GetString("Failed database conversion, ensure you have libsqlite3-0 installed. \nIf problems persist ask in chronojump-list");
                    errorMessage += "\n\n" + string.Format(Catalog.GetString("If you have no data on your database (you just installed Chronojump), you can fix this problem deleting this file: {0}"),
                                                           Util.GetDatabaseDir() + Path.DirectorySeparatorChar + "chronojump.db") +
                                    "\n" + Catalog.GetString("And starting Chronojump again.");
                    LogB.Error(errorMessage);
                    messageToShowOnBoot += errorMessage;
                    chronojumpHasToExit  = true;
                    return;
                }
                Sqlite.Connect();
            }

            splashMessageChange(4);              //updating DB
            updatingDB = true;

            if (Sqlite.ChangeDjToDJna())
            {
                messageToShowOnBoot += Catalog.GetString("All DJ jumps have been renamed as 'DJna' (Drop Jumps with No Arms).") + "\n\n" +
                                       Catalog.GetString("If your Drop Jumps were executed using the arms, please rename them manually as 'DJa'.") + "\n";
            }

            bool softwareIsNew = Sqlite.ConvertToLastChronojumpDBVersion();
            updatingDB = false;


            if (!softwareIsNew)
            {
                //Console.Clear();
                string errorMessage = string.Format(Catalog.GetString("Sorry, this Chronojump version ({0}) is too old for your database."), progVersion) + "\n" +
                                      Catalog.GetString("Please update Chronojump") + ":\n";
                errorMessage += "http://chronojump.org";
                //errorMessage += "\n\n" + Catalog.GetString("Press any key");
                LogB.Error(errorMessage);
                messageToShowOnBoot += errorMessage;
                chronojumpHasToExit  = true;
            }

            LogB.Information(Catalog.GetString("tables already created"));


            //check for bad Rjs (activate if program crashes and you use it in the same db before v.0.41)
            //SqliteJump.FindBadRjs();

            createRunningFileName(runningFileName);
        }


        //splashMessageChange(5);  //check for new version
        splashMessageChange(5);          //connecting to server

        messageToShowOnBoot += recuperateBrokenEvents();

        //connect to server to Ping
        versionAvailable = "";
        versionAvailable = Constants.ServerOffline;


        //doing ping using json methods

        /*
         * temporarily disabled on start
         * string machineID = SqlitePreferences.Select("machineID", false);
         * Json js = new Json();
         * bool success = js.Ping(UtilAll.GetOS(), progVersion, machineID);
         * if(success)
         *      LogB.Information(js.ResultMessage);
         * else
         *      LogB.Error(js.ResultMessage);
         */

        allSQLCallsDoneOnSqliteThingsThread = false;

        //wait until pinging ends (or it's cancelled)
        //while(! pingEnd) {
        //}

        Sqlite.Open();

//TODO: fix this to the new code

        string versionAvailableKnown = SqlitePreferences.Select("versionAvailable", true);

        if (versionAvailable != Constants.ServerOffline && new Version(versionAvailable) > new Version(progVersion))
        {
            //check if available version is higher than known available version
            Version versionAvailableAsV = new Version(versionAvailable);

            Version versionAvailableKnownAsV;
            bool    updateKnownVersion = false;
            if (versionAvailableKnown == "")
            {
                updateKnownVersion = true;
            }
            else
            {
                versionAvailableKnownAsV = new Version(versionAvailableKnown);
                if (versionAvailableAsV > versionAvailableKnownAsV)
                {
                    updateKnownVersion = true;
                }
            }

            if (updateKnownVersion)
            {
                //is the first time we know about this new version
                //just write on db and show message to user
                SqlitePreferences.Update(Constants.PrefVersionAvailable, versionAvailable, true);
                versionAvailableKnown = versionAvailable;
                messageToShowOnBoot  += string.Format(Catalog.GetString(
                                                          "\nNew Chronojump version available on website.\nYour Chronojump version is: {1}"),
                                                      versionAvailable, progVersion) + "\n\n" +
                                        Catalog.GetString("Please, update to new version.") + "\n";
            }
        }


        //if chronojump chrashed before
        if (badExit)
        {
            if (versionAvailableKnown.Length > 0 && new Version(versionAvailableKnown) > new Version(progVersion))
            {
                messageToShowOnBoot += "\n" + Catalog.GetString("Chronojump crashed before.") + "\n" +
                                       Catalog.GetString("Please, update to new version: ") + versionAvailableKnown + "\n";
            }
            else
            {
                messageToShowOnBoot += messageCrashedBefore;
                //SqlitePreferences.Update("videoOn", "False", true);
            }
        }


        splashMessageChange(6);          //preparing main window


        //start as "simulated"
        SqlitePreferences.Update("simulated", "True", true);         //dbcon opened

        Sqlite.Close();

        // Chronojump sqlite is in an initialized state, let's keep the Sqlite state here
        // to be re-used
        Sqlite.saveClassState();

        allSQLCallsDoneOnSqliteThingsThread = true;
        LogB.SQL("all SQL calls done on sqliteThings thread");

        UtilAll.IsWindows();            //only as additional info here

        //Application.Init();

        needEndSplashWin = true;
    }
コード例 #20
0
    public bool Capture(string outputData1, EncoderRProcCapture encoderRProcCapture)
    {
        if (simulated)
        {
            bool success = initSimulated();
            if (!success)
            {
                return(false);
            }
        }

        do
        {
            try {
                byteReaded = readByte();
            } catch {
                if (!simulated)
                {
                    LogB.Error("Maybe encoder cable is disconnected");
                    cancel = true;
                }

                break;
            }

            byteReaded = convertByte(byteReaded);

            i = i + 1;
            if (i >= 0)
            {
                if (cont)
                {
                    recordedTimeCont++;
                }

                if (inertialCaptureDirectionInverted)
                {
                    byteReaded *= -1;
                }

                if (byteReaded == 0)
                {
                    consecutiveZeros++;
                }
                else
                {
                    consecutiveZeros = -1;
                }

                //stop if n seconds of inactivity
                //but it has to be moved a little bit first, just to give time to the people
                //if(consecutiveZeros >= consecutiveZerosMax && sum > 0) #Not OK because sum maybe is 0: +1,+1,-1,-1
                //if(consecutiveZeros >= consecutiveZerosMax && ecca.ecc.Count > 0) #Not ok because when ecca is created, ecc.Count == 1
                //
                //process ends
                //when a curve has been found and then there are n seconds of inactivity, or
                //when a curve has not been found and then there are 2*n seconds of inactivity
                if (
                    (Ecca.curvesAccepted > 0 && consecutiveZeros >= consecutiveZerosMax) ||
                    (!cont && Ecca.curvesAccepted == 0 && consecutiveZeros >= (2 * consecutiveZerosMax)))
                {
                    finish = true;
                    LogB.Information("SHOULD FINISH");
                }


                sumInertialDisc += byteReaded;
                encoderReadedInertialDisc.Add(byteReaded);

                if (inertialChangedConToEcc())
                {
                    byteReaded *= -1;
                }

                sum += byteReaded;
                encoderReaded.Add(byteReaded);

                assignEncoderCapturePoints();

                EncoderCapturePointsCaptured = i;

                //this only applies to inertial subclass
                if (inertialShouldCheckStartDirection)
                {
                    inertialCheckIfInverted();
                }

                encoderCapturePointsAdaptativeDisplay();

                // ---- prepare to send to R ----

                //if string goes up or down, store the direction
                //direction is only up or down
                if (byteReaded != 0)
                {
                    directionNow = (int)byteReaded / (int)Math.Abs(byteReaded);                       //1 (up) or -1 (down)
                }
                //if we don't have changed the direction, store the last non-zero that we can find
                if (directionChangeCount == 0 && directionNow == directionLastMSecond)
                {
                    //check which is the last non-zero value
                    //this is suitable to find where starts the only-zeros previous to the change
                    if (byteReaded != 0)
                    {
                        lastNonZero = i;
                    }
                }

                bool sendCurveMaybe = false;

                //if it's different than the last direction, mark the start of change
                if (directionNow != directionLastMSecond)
                {
                    directionLastMSecond = directionNow;
                    directionChangeCount = 0;
                }
                else if (directionNow != directionCompleted)
                {
                    //we are in a different direction than the last completed

                    //we cannot add byteReaded because then is difficult to come back n frames to know the max point
                    //directionChangeCount += byteReaded
                    directionChangeCount++;

                    if (directionChangeCount > directionChangePeriod)                           //count >= than change_period
                    {
                        sendCurveMaybe = true;
                    }
                }

                if (sendCurveMaybe)
                {
                    //int startFrame = previousFrameChange - directionChangeCount;	//startFrame

                    /*
                     * at startFrame we do the "-directionChangePeriod" because
                     * we want data a little bit earlier, because we want some zeros
                     * that will be removed by reduceCurveBySpeed
                     * if not done, then the data:
                     * 0 0 0 0 0 0 0 0 0 1
                     * will start at 10th digit (the 1)
                     * if done, then at speed will be like this:
                     * 0 0 0 0.01 0.04 0.06 0.07 0.08 0.09 1
                     * and will start at fourth digit
                     */

                    //this is better, takes a lot of time before, and then reduceCurveBySpeed will cut it
                    //but reduceCurveBySpeed is not implemented on inertial
                    //TODO: implement it
                    int startFrame = previousEnd;                       //startFrame
                    LogB.Debug("startFrame", startFrame.ToString());
                    if (startFrame < 0)
                    {
                        startFrame = 0;
                    }

                    LogB.Information("TTTT - i," + i.ToString() +
                                     "; directionChangeCount: " +
                                     directionChangeCount.ToString() +
                                     "; lastNonZero: " +
                                     lastNonZero.ToString() +
                                     "; final: " +
                                     ((i - directionChangeCount + lastNonZero) / 2).ToString());

                    ecc = new EncoderCaptureCurve(
                        startFrame,
                        (i - directionChangeCount + lastNonZero) / 2                                    //endFrame
                        //to find endFrame, first substract directionChangePeriod from i
                        //then find the middle point between that and lastNonZero
                        //this means that the end is in central point at displacements == 0
                        );

                    //since 1.5.0 secundary thread is capturing and sending data to R process
                    //while main thread is reading data coming from R and updating GUI

                    LogB.Debug("curve stuff" + ecc.startFrame + ":" + ecc.endFrame + ":" + encoderReaded.Count);
                    if (ecc.endFrame - ecc.startFrame > 0)
                    {
                        double [] curve = new double[ecc.endFrame - ecc.startFrame];
                        int       mySum = 0;
                        for (int k = 0, j = ecc.startFrame; j < ecc.endFrame; j++)
                        {
                            curve[k] = encoderReaded[j];
                            k++;
                            mySum += encoderReaded[j];
                        }
                        ecc.up = (mySum >= 0);

                        previousEnd = ecc.endFrame;

                        //22-may-2015: This is done in R now

                        //1) check heightCurve in a fast way first to discard curves soon
                        //   only process curves with height >= min_height
                        //2) if it's concentric, only take the concentric curves,
                        //   but if it's concentric and inertial: take both.
                        //
                        //   When capturing on inertial, we have the first graph
                        //   that will be converted to the second.
                        //   we need the eccentric phase in order to detect the Ci2

                        /*
                         *             /\
                         *            /  \
                         *           /    \
                         *____      C1     \      ___
                         *    \    /        \    /
                         *     \  /          \  C2
                         *      \/            \/
                         *
                         * C1, C2: two concentric phases
                         */

                        /*
                         *____                    ___
                         *    \    /\      /\    /
                         *     \ Ci1 \   Ci2 \ Ci3
                         *      \/    \  /    \/
                         *             \/
                         *
                         * Ci1, Ci2, Ci3: three concentric phases on inertial
                         *
                         * Since 1.6.1:
                         * on inertial curve is sent when rope is fully extended,
                         * this will allow to see at the moment c or e. Not wait the change of direction to see both
                         */


                        if (shouldSendCurve())
                        {
                            encoderRProcCapture.SendCurve(
                                UtilEncoder.CompressData(curve, 25)                                             //compressed
                                );

                            Ecca.curvesAccepted++;
                            Ecca.ecc.Add(ecc);

                            lastDirectionStoredIsUp = ecc.up;
                        }
                    }

                    //on inertial is different
                    markDirectionChanged();
                }

                //this is for visual feedback of remaining time
                msCount++;
                if (msCount >= 1000)
                {
                    Countdown--;
                    msCount = 1;
                }
            }
        } while ((cont || i < (recordingTime - 1)) && !cancel && !finish);

        LogB.Debug("runEncoderCaptureCsharp main bucle end");

        //leave some time to capture.R be able to paint data, and to create two Roptions.txt file correctly
        if (simulated)
        {
            System.Threading.Thread.Sleep(2000);
        }
        else
        {
            sp.Close();
        }

        if (cancel)
        {
            return(false);
        }

        saveToFile(outputData1);

        LogB.Debug("runEncoderCaptureCsharp ended");

        return(true);
    }
コード例 #21
0
 public bool CallR(int graphWidth, int graphHeight)
 {
     LogB.Information("\nrunEncoder CallR ----->");
     writeOptionsFile(graphWidth, graphHeight);
     return(ExecuteProcess.CallR(UtilEncoder.GetRaceAnalyzerScript()));
 }
コード例 #22
0
ファイル: sprint.cs プロジェクト: davidfombella/chronojump
    /*
     * public Sprint(List<double> positions, List<double> splitTimes,
     *              double mass, double personHeight, double tempC)
     * {
     *      this.positions = positions;
     *      this.splitTimes = splitTimes;
     *      this.mass = mass;
     *      this.personHeight = personHeight;
     *      this.tempC = tempC;
     * }
     */

    public bool CallR(int graphWidth, int graphHeight, string personName)
    {
        LogB.Information("\nsprint CallR ----->");
        writeOptionsFile(graphWidth, graphHeight, personName);
        return(ExecuteProcess.CallR(UtilEncoder.GetSprintPhotocellsScript()));
    }
コード例 #23
0
    protected override bool continueProcess()
    {
        CurvesReaded = 0;

        //TODO: outputFileCheck creation/deletion here and at startProcess, should be unique
        string outputFileCheck  = "";
        string outputFileCheck2 = "";

        if (es.Ep.Analysis == "exportCSV")
        {
            outputFileCheck = es.OutputData1;
        }
        else
        {
            //outputFileCheck = es.OutputGraph;
            //
            //OutputData1 because since Chronojump 1.3.6,
            //encoder analyze has a treeview that can show the curves
            //when a graph analysis is done, curves file has to be written
            outputFileCheck = es.OutputData1;
            //check also the otuput graph
            outputFileCheck2 = es.OutputGraph;
        }

        //delete output file check(s)
        deleteFile(outputFileCheck);
        if (outputFileCheck2 != "")
        {
            deleteFile(outputFileCheck2);
        }

        //delete status-6 mark used on export csv
        if (es.Ep.Analysis == "exportCSV")
        {
            Util.FileDelete(UtilEncoder.GetEncoderStatusTempBaseFileName() + "6.txt");
        }

        //delete SpecialData if exists
        string specialData = UtilEncoder.GetEncoderSpecialDataTempFileName();

        if (File.Exists(specialData))
        {
            File.Delete(specialData);
        }



        LogB.Debug("sending continue process");
        //try/catch because sometimes the stdin write gots broken
        try {
            p.StandardInput.WriteLine("C");
        } catch {
            LogB.Debug("calling start because continue process was problematic");
            return(startProcess());
        }

        LogB.Debug("waiting files");
        if (outputFileCheck2 == "")
        {
            while (!(Util.FileReadable(outputFileCheck) || CancelRScript))
            {
                ;
            }
        }
        else
        {
            while (!((Util.FileReadable(outputFileCheck) && Util.FileReadable(outputFileCheck2)) || CancelRScript))
            {
                ;
            }
        }

        //copy export from temp file to the file that user has selected
        if (es.Ep.Analysis == "exportCSV" && !CancelRScript)
        {
            copyExportedFile();
        }

        LogB.Debug("files written");

        return(true);
    }
コード例 #24
0
    protected override bool startProcess()
    {
        CurvesReaded = 0;

        //If output file is not given, R will try to write in the running folder
        //in which we may haven't got permissions

        pinfo = new ProcessStartInfo();

        string pBin = pBinURL();

        if (UtilAll.IsWindows())
        {
            //On win32 R understands backlash as an escape character and
            //a file path uses Unix-like path separator '/'
            optionsFile = optionsFile.Replace("\\", "/");
        }

        //on Windows we need the \"str\" to call without problems in path with spaces
        pinfo.Arguments = "\"" + getEncoderScriptCallGraph() + "\" " + optionsFile;

        LogB.Information("Arguments:", pinfo.Arguments);
        LogB.Information("--- 1 --- " + optionsFile.ToString() + " ---");
        //LogB.Information("--- 2 --- " + scriptOptions + " ---");
        LogB.Information("--- 3 --- " + pinfo.Arguments.ToString() + " ---");

        string outputFileCheck  = "";
        string outputFileCheck2 = "";

        //Wait until this to update encoder gui (if don't wait then treeview will be outdated)
        //exportCSV is the only one that doesn't have graph. all the rest Analysis have graph and data
        if (es.Ep.Analysis == "exportCSV")
        {
            outputFileCheck = es.OutputData1;
        }
        else
        {
            //outputFileCheck = es.OutputGraph;
            //
            //OutputData1 because since Chronojump 1.3.6,
            //encoder analyze has a treeview that can show the curves
            //when a graph analysis is done, curves file has to be written
            outputFileCheck = es.OutputData1;
            //check also the otuput graph
            outputFileCheck2 = es.OutputGraph;
        }

        LogB.Information("outputFileChecks");
        LogB.Information(outputFileCheck);
        LogB.Information(outputFileCheck2);

        pinfo.FileName = pBin;

        pinfo.CreateNoWindow        = true;
        pinfo.UseShellExecute       = false;
        pinfo.RedirectStandardInput = true;
        pinfo.RedirectStandardError = true;

        /*
         * if redirect this there are problems because the buffers get saturated
         * pinfo.RedirectStandardOutput = true;
         * if is not redirected, then prints are shown by console (but not in logB
         * best solution is make the prints as write("message", stderr())
         * and then will be shown in logB by readError
         */


        //delete output file check(s)
        deleteFile(outputFileCheck);
        if (outputFileCheck2 != "")
        {
            deleteFile(outputFileCheck2);
        }

        //delete status-6 mark used on export csv
        if (es.Ep.Analysis == "exportCSV")
        {
            Util.FileDelete(UtilEncoder.GetEncoderStatusTempBaseFileName() + "6.txt");
        }

        //delete SpecialData if exists
        string specialData = UtilEncoder.GetEncoderSpecialDataTempFileName();

        if (File.Exists(specialData))
        {
            File.Delete(specialData);
        }


        try {
            p           = new Process();
            p.StartInfo = pinfo;

            //do not redirect ouptut. Read above
            //p.OutputDataReceived += new DataReceivedEventHandler(readingOutput);
            p.ErrorDataReceived += new DataReceivedEventHandler(readingError);

            p.Start();

            //don't do this ReadToEnd because then this method never ends
            //LogB.Information(p.StandardOutput.ReadToEnd());
            //LogB.Warning(p.StandardError.ReadToEnd());

            // Start asynchronous read of the output.
            // Caution: This has to be called after Start
            //p.BeginOutputReadLine();
            p.BeginErrorReadLine();


            if (outputFileCheck2 == "")
            {
                while (!(Util.FileReadable(outputFileCheck) || CancelRScript))
                {
                    ;
                }
            }
            else
            {
                while (!((Util.FileReadable(outputFileCheck) && Util.FileReadable(outputFileCheck2)) || CancelRScript))
                {
                    ;
                }
            }

            //copy export from temp file to the file that user has selected
            if (es.Ep.Analysis == "exportCSV" && !CancelRScript)
            {
                copyExportedFile();
            }
        } catch {
            LogB.Warning("catched at startProcess");
            return(false);
        }

        return(true);
    }
コード例 #25
0
    /*
     * Use this to retrieve values after accept
     * do not use to know current encoder configuration
     * because that is stored in gui/encoder as
     * encoderConfigurationCurrent
     */
    public EncoderConfiguration GetAcceptedValues()
    {
        EncoderConfiguration ec = (EncoderConfiguration)list[listCurrent];

        ec.d                 = -1;
        ec.list_d            = new List_d();
        ec.D                 = -1;
        ec.anglePush         = -1;
        ec.angleWeight       = -1;
        ec.inertiaMachine    = -1;
        ec.gearedDown        = 1;
        ec.inertiaTotal      = -1;
        ec.extraWeightN      = 0;
        ec.extraWeightGrams  = 0;
        ec.extraWeightLength = 1;

        if (ec.has_d)
        {
            if (ec.has_inertia)
            {
                ec.list_d = get_list_d();

                bool found = false;
                if (Util.IsNumber(main_gui_anchorage_str, true))
                {
                    LogB.Information("main_gui_anchorage = " + main_gui_anchorage_str);
                    double guiAnchorage = Convert.ToDouble(main_gui_anchorage_str);
                    foreach (double d in ec.list_d.L)
                    {
                        LogB.Information("d = " + d.ToString());
                        if (d == guiAnchorage)
                        {
                            ec.d  = guiAnchorage;
                            found = true;
                            break;
                        }
                    }
                }

                if (!found)
                {
                    ec.d = ec.list_d.L[0];
                }
            }
            else
            {
                ec.d = (double)spin_d.Value;
            }
        }

        if (ec.has_D)
        {
            ec.D = (double)spin_D.Value;
        }

        if (ec.has_angle_push)
        {
            ec.anglePush = (int)spin_angle_push.Value;
        }

        if (ec.has_angle_weight)
        {
            ec.angleWeight = (int)spin_angle_weight.Value;
        }

        if (ec.has_inertia)
        {
            ec.inertiaMachine    = (int)spin_inertia_machine.Value;
            ec.extraWeightN      = main_gui_extraWeightN;
            ec.extraWeightGrams  = (int)spin_inertia_mass.Value;
            ec.extraWeightLength = (double)spin_inertia_length.Value;

            ec.inertiaTotal = UtilEncoder.CalculeInertiaTotal(ec);
        }

        if (ec.has_gearedDown)
        {
            ec.SetGearedDownFromDisplay(UtilGtk.ComboGetActive(combo_gearedUp));
        }

        return(ec);
    }