Home | History | Annotate | Download | only in classifier 
      1 /*
      2  * Copyright (C) 2015 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License
     15  */
     16 
     17 package com.android.systemui.classifier;
     18 
     19 import android.view.MotionEvent;
     20 
     21 import java.util.ArrayList;
     22 import java.util.HashMap;
     23 import java.util.List;
     24 
     25 /**
     26  * A classifier which for each point from a stroke, it creates a point on plane with coordinates
     27  * (timeOffsetNano, distanceCoveredUpToThisPoint) (scaled by DURATION_SCALE and LENGTH_SCALE)
     28  * and then it calculates the angle variance of these points like the class
     29  * {@link AnglesClassifier} (without splitting it into two parts). The classifier ignores
     30  * the last point of a stroke because the UP event comes in with some delay and this ruins the
     31  * smoothness of this curve. Additionally, the classifier classifies calculates the percentage of
     32  * angles which value is in [PI - ANGLE_DEVIATION, 2* PI) interval. The reason why the classifier
     33  * does that is because the speed of a good stroke is most often increases, so most of these angels
     34  * should be in this interval.
     35  */
     36 public class SpeedAnglesClassifier extends StrokeClassifier {
     37     private HashMap<Stroke, Data> mStrokeMap = new HashMap<>();
     38 
     39     public SpeedAnglesClassifier(ClassifierData classifierData) {
     40         mClassifierData = classifierData;
     41     }
     42 
     43     @Override
     44     public String getTag() {
     45         return "SPD_ANG";
     46     }
     47 
     48     @Override
     49     public void onTouchEvent(MotionEvent event) {
     50         int action = event.getActionMasked();
     51 
     52         if (action == MotionEvent.ACTION_DOWN) {
     53             mStrokeMap.clear();
     54         }
     55 
     56         for (int i = 0; i < event.getPointerCount(); i++) {
     57             Stroke stroke = mClassifierData.getStroke(event.getPointerId(i));
     58 
     59             if (mStrokeMap.get(stroke) == null) {
     60                 mStrokeMap.put(stroke, new Data());
     61             }
     62 
     63             if (action != MotionEvent.ACTION_UP && action != MotionEvent.ACTION_CANCEL
     64                     && !(action == MotionEvent.ACTION_POINTER_UP && i == event.getActionIndex())) {
     65                 mStrokeMap.get(stroke).addPoint(
     66                         stroke.getPoints().get(stroke.getPoints().size() - 1));
     67             }
     68         }
     69     }
     70 
     71     @Override
     72     public float getFalseTouchEvaluation(int type, Stroke stroke) {
     73         Data data = mStrokeMap.get(stroke);
     74         return SpeedVarianceEvaluator.evaluate(data.getAnglesVariance())
     75                 + SpeedAnglesPercentageEvaluator.evaluate(data.getAnglesPercentage());
     76     }
     77 
     78     private static class Data {
     79         private final float DURATION_SCALE = 1e8f;
     80         private final float LENGTH_SCALE = 1.0f;
     81         private final float ANGLE_DEVIATION = (float) Math.PI / 10.0f;
     82 
     83         private List<Point> mLastThreePoints = new ArrayList<>();
     84         private Point mPreviousPoint;
     85         private float mPreviousAngle;
     86         private float mSumSquares;
     87         private float mSum;
     88         private float mCount;
     89         private float mDist;
     90         private float mAnglesCount;
     91         private float mAcceleratingAngles;
     92 
     93         public Data() {
     94             mPreviousPoint = null;
     95             mPreviousAngle = (float) Math.PI;
     96             mSumSquares = 0.0f;
     97             mSum = 0.0f;
     98             mCount = 1.0f;
     99             mDist = 0.0f;
    100             mAnglesCount = mAcceleratingAngles = 0.0f;
    101         }
    102 
    103         public void addPoint(Point point) {
    104             if (mPreviousPoint != null) {
    105                 mDist += mPreviousPoint.dist(point);
    106             }
    107 
    108             mPreviousPoint = point;
    109             Point speedPoint = new Point((float) point.timeOffsetNano / DURATION_SCALE,
    110                     mDist / LENGTH_SCALE);
    111 
    112             // Checking if the added point is different than the previously added point
    113             // Repetitions are being ignored so that proper angles are calculated.
    114             if (mLastThreePoints.isEmpty()
    115                     || !mLastThreePoints.get(mLastThreePoints.size() - 1).equals(speedPoint)) {
    116                 mLastThreePoints.add(speedPoint);
    117                 if (mLastThreePoints.size() == 4) {
    118                     mLastThreePoints.remove(0);
    119 
    120                     float angle = mLastThreePoints.get(1).getAngle(mLastThreePoints.get(0),
    121                             mLastThreePoints.get(2));
    122 
    123                     mAnglesCount++;
    124                     if (angle >= (float) Math.PI - ANGLE_DEVIATION) {
    125                         mAcceleratingAngles++;
    126                     }
    127 
    128                     float difference = angle - mPreviousAngle;
    129                     mSum += difference;
    130                     mSumSquares += difference * difference;
    131                     mCount += 1.0;
    132                     mPreviousAngle = angle;
    133                 }
    134             }
    135         }
    136 
    137         public float getAnglesVariance() {
    138             return mSumSquares / mCount - (mSum / mCount) * (mSum / mCount);
    139         }
    140 
    141         public float getAnglesPercentage() {
    142             if (mAnglesCount == 0.0f) {
    143                 return 1.0f;
    144             }
    145             return (mAcceleratingAngles) / mAnglesCount;
    146         }
    147     }
    148 }