public static CompressData ( double curve, int valuesForNewLine ) : string | ||
curve | double | |
valuesForNewLine | int | |
return | string |
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); }
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); }