Ejemplo n.º 1
0
        /**
         * Constructor.
         */
        public Jackknife(JackknifeBlades blades)
        {
            if (!(blades.InnerProduct ^ blades.EuclideanDistance))
            {
                throw new ArgumentException("!(blades.InnerProduct ^ blades.EuclideanDistance)");
            }

            this.Blades = blades;
            templates   = new List <JackknifeTemplate>();
        }
Ejemplo n.º 2
0
        /**
         * Constructor.
         */
        public Jackknife(JackknifeBlades blades)
        {
            if (!(blades.InnerProduct ^ blades.EuclideanDistance))
            {
                throw new ArgumentException("!(blades.InnerProduct ^ blades.EuclideanDistance)");
            }

            this.Blades     = blades;
            templates       = new List <JackknifeTemplate>();
            templateLenghts = new Dictionary <int, int>();
            maxTemplateLen  = 0;
            minTemplateLen  = int.MaxValue;
        }
Ejemplo n.º 3
0
        /**
         * Constructor.
         */
        public JackknifeTemplate(JackknifeBlades blades, Sample sample)
        {
            this.Sample = sample;
            GestureId   = sample.GestureId;
            // Any default value less than zero will ensure if
            // lower bounding is disabled, we don't cull any
            // instance.
            LB = -1;

            // A default value of one will ensure that the DTW
            // score is not modified when all correction factors
            // are disabled.
            CF = 1;

            // A default value that will never cause rejection.
            // So if the recognizer is not trained, things will
            // still work as expected.
            RejectionThreshold = double.PositiveInfinity;
            Lower = new List <Vector>();
            Upper = new List <Vector>();

            // Extract import information about the sample.
            Features = new JackknifeFeatures(blades, sample.Trajectory);
            List <Vector> vecs         = Features.Vecs;
            int           componentCnt = vecs[0].Size;

            // For each component find the min and max value
            // within the radius (Sakoe-Chiba band).
            for (int i = 0; i < vecs.Count; i++)
            {
                Vector maximum = new Vector(double.NegativeInfinity, componentCnt);
                Vector minimum = new Vector(double.PositiveInfinity, componentCnt);

                for (int j = Math.Max(0, i - blades.Radius); j < Math.Min(i + blades.Radius + 1, vecs.Count); j++)
                {
                    for (int k = 0; k < componentCnt; k++)
                    {
                        maximum[k] = Math.Max(maximum[k], vecs[j][k]);
                        minimum[k] = Math.Min(minimum[k], vecs[j][k]);
                    }
                }

                Upper.Add(maximum);
                Lower.Add(minimum);
            }
        }
Ejemplo n.º 4
0
        /**
         * The main data extraction work is done in the constructor.
         *
         * This is where we:
         *
         *      1) Resample the trajectory to a fixed number
         *         of points (resample_cnt).
         *
         *      2) Calculate the normalized direction vector
         *         between each resampled point or the z-score
         *         normalized points.
         *
         *      3) Extract correction factor related data.
         *
         * It is highly recommended that the sample trajectory points
         * have been smoothed with a low pass filter before calling
         * this function. A simple exponential smoothing filter will
         * probably be adequate for most case.
         */
        public JackknifeFeatures(JackknifeBlades blades, List <Vector> points)
        {
            this.Vecs = new List <Vector>();

            // Number of components per point.
            int m = points[0].Size;

            // resample the trajectory to a fixed number of points
            this.Pts = Mathematics.Resample(points, blades.ResampleCnt);

            // To track the bounding box widths,
            // start with one point and expand.
            Vector minimum = new Vector(Pts[0].Data);
            Vector maximum = new Vector(Pts[0].Data);

            // The abs distance traversed starts with zeros.
            this.Abs = new Vector(0, m);

            // Incrementally extract information.
            for (int i = 1; i < blades.ResampleCnt; i++)
            {
                // In-between point direction vector.
                Vector vec = Pts[i] - Pts[i - 1];

                // Update correction factor features.
                for (int j = 0; j < m; j++)
                {
                    this.Abs[j] += Math.Abs(vec[j]);
                    minimum[j]   = Math.Min(minimum[j], Pts[i][j]);
                    maximum[j]   = Math.Max(maximum[j], Pts[i][j]);
                }

                // Save the points or direction vectors,
                // depending on the selected measure.
                if (blades.InnerProduct)
                {
                    this.Vecs.Add(vec.Normalize());
                }
                else if (blades.EuclideanDistance)
                {
                    // In ED scenario, make sure not to forget first point as
                    // loop starts at 1.
                    if (i == 1)
                    {
                        this.Vecs.Add(Pts[0]);
                    }

                    this.Vecs.Add(Pts[i]);
                }
                else
                {
                    throw new Exception("This should not happen!");
                }
            }

            // Z-score normalize the vecs if required,
            // typically only if using euclidean distance
            if (blades.ZNormalize)
            {
                Mathematics.ZNormalize(this.Vecs);
            }

            // normalize the correction factor vectors
            this.Abs.Normalize();
            this.Bb = (maximum - minimum).Normalize();
        }