Sorry your browser is not supported!

#Constant INT_MAX 2147483647
#Constant pointsPerStroke 32
#Constant totalStrokes 10
#Constant scaleSize 100.0
 
 
`Our screen coords
Type vec2
   x As Integer
   y As Integer
EndType
 
`An extra one for storing the dot product once a database submission is made
Type vec3
   x As Integer
   y As Integer
   dotProd As Float
EndType
 
 
`Our list of coords (Yes, a "List", not an array)
Global Dim stroke(-1) As vec2
 
`Our list of possible gestures
`Unfortunatly, due to DBP's limitations, it is not possible to create a dynamic
` (expandable and contractable) Array (ie, a List) that is more than 1D.
` As such, we have to create a "Max Size" for the gestures.
` total is easily changable via the constant definition
Global Dim strokeDB(totalStrokes,pointsPerStroke) As vec3
 
Global currentTotalStrokes As Integer = 0
 
match As Integer
 
remstart
   `Call this to add the first point to the current gesture (stroke)
   getStroke(1, X, Y)
 
   `Then this to add subsequent points
   getStroke(0, X, Y)
 
   `Call these in order to perform the actions needed
   normalizeSize()
   normalizeSpacing()
   normalizeCenter()
   match = findMatch()
 
   `Add the current gesture to the database
   storeStroke()
remend
 
Function findMatch()
 
   bestScore As Float
   bestScoreIndex As Integer
   score As Float
   bestScoreIndex = -1
   bestScore = -1.0
 
   strokeDotProd As Float
   Array Index To Top stroke()
   While Array Index Valid(stroke())
      `And the inner product of it with itself
      strokeDotProd = strokeDotProd + (stroke().x * stroke().x) + (stroke().y * stroke().y)
      Next Array Index stroke()
   EndWhile
 
   For m = 0 To currentTotalStrokes - 1
      score = gestureDotProduct(m)
      score = score / Sqrt(strokeDotProd * strokeDB(m,0).dotProd)
      If score >= 0.0 And score > bestScore
         bestScore = score
         bestScoreIndex = m
      EndIf
   Next m
 
EndFunction bestScoreIndex
 
 
 
Function gestureDotProduct(index As Integer)
 
   dotProd As Float
 
   i As Integer
   i = 0
   Array Index To Top stroke()
   While Array Index Valid(stroke()) AND i <= pointsPerStroke
      `And the inner product of it with itself
      dotProd = dotProd + (strokeDB(index,i).x * stroke().x) + (strokeDB(index,i).y * stroke().y)
      Inc i
      Next Array Index stroke()
   EndWhile
 
EndFunction dotProd
 
 
 
Function storeStroke()
 
   If Array Count(stroke()) <= 1 Then ExitFunction
   If currentTotalStrokes = totalStrokes Then ExitFunction
 
   dotProd As Float
   i As Integer
   i = 0
   Array Index To Top stroke()
   While i < pointsPerStroke
      `Store the points
      strokeDB(currentTotalStrokes,i).x = stroke().x
      strokeDB(currentTotalStrokes,i).y = stroke().y
      `And the inner product of it with itself
      strokeDB(currentTotalStrokes,0).dotProd = strokeDB(currentTotalStrokes,0).dotProd + (stroke().x * stroke().x) + (stroke().y * stroke().y)
      Inc i
      Next Array Index stroke()
   EndWhile
 
   Inc currentTotalStrokes
 
EndFunction
 
 
 
 
Function getStroke(startStroke As Boolean, x As Integer, y As Integer)
 
   If startStroke Then Array Index To Top stroke()
 
   Next Array Index stroke()
 
   If Array Index Valid(stroke()) = 0 Then Array Insert At Bottom stroke()
 
   stroke().x = x
   stroke().y = y
 
EndFunction
 
 
Function normalizeSize()
 
   minX As Integer = INT_MAX
   maxX As Integer = -INT_MAX
   minY As Integer = INT_MAX
   maxY As Integer = -INT_MAX
 
   width As Float
   height As Float
 
   scale As Float
 
   Array Index To Top stroke()
   While Array Index Valid(stroke())
 
      If minX > stroke().x Then minX = stroke().x
      If minY > stroke().y Then minY = stroke().y
      If maxX < stroke().x Then maxX = stroke().x
      If maxY < stroke().y Then maxY = stroke().y
 
      Next Array Index stroke()
 
   EndWhile
 
   width = maxX - minX
   height = maxY - minY
 
   If width > height Then scale = width Else scale = height
   If scale = 0.0 Then ExitFunction
 
   Array Index To Top stroke()
   While Array Index Valid(stroke())
 
      stroke().x = Int(stroke().x * 1.0 / scale * scaleSize)
      stroke().y = Int(stroke().y * 1.0 / scale * scaleSize)
 
      Next Array Index stroke()
 
   EndWhile
 
 
EndFunction
 
 
Function getStrokeLength()
 
   If Array Count(stroke()) <= 1 Then ExitFunction 0.0
 
   Local length As Float
   Local dx As Float
   Local dy As Float
   Local start As vec2
 
   Array Index To Top stroke()
 
   start = stroke()
   Next Array Index stroke()
 
   While Array Index Valid(stroke())
 
      dx = (stroke().x * 1.0) - (start.x * 1.0)
      dy = (stroke().y * 1.0) - (start.y * 1.0)
 
      length = length + Sqrt((dx*dx) + (dy*dy))
 
      start = stroke()
 
      Next Array Index stroke()
   EndWhile
 
EndFunction length
 
 
Function normalizeSpacing()
 
   `Variables needed
   Local newSegmentLen As Float
   Local curSegmentLen As Float
   Local endOldDist As Float
   Local startOldDist As Float
   Local newDist As Float
   Local excess As Float
   Local ratio As Float
   Local dx As Float
   Local dy As Float
 
   Local startPt As vec2
   Local endPt As vec2
   Local newPt As vec2
 
   `Temp List to store the normalSpaced points
   Local Dim newStroke(0) As vec2
 
   `Get the total length of the original stroke
   newSegmentLen = getStrokeLength()
 
   If Array Count(stroke()) <= 1 Or newSegmentLen <= 0.0 Then ExitFunction
 
   `Average length per segment
   newSegmentLen = newSegmentLen / (pointsPerStroke * 1.0)
 
   `Go to the start of our Lists
   Array Index To Top newStroke()
   Array Index To Top stroke()
 
   `Set the first point in the temp List to that of the first in the original List
   newStroke() = stroke()
 
   startPt = stroke()   `Ends of the current segment
   endPt = stroke()     `(Begin with the empty Segment)
 
   `Move along one in the original List
   Next Array Index stroke()
 
   `Infinate Loop (10000 itterations for a fail-safe)
   For i = 0 To 10000
 
      `Distance from our last new point
      excess = endOldDist - newDist
 
      `There's enough length, so add a point
      If excess >= newSegmentLen
         newDist = newDist + newSegmentLen                     `Tally the total distance traveled from the first point
         ratio = (newDist - startOldDist) / curSegmentLen      `The ratio of the average length between points
         newPt.x = (endPt.x - startPt.x) * ratio + startPt.x   `Determine the position of the new point based on these
         newPt.y = (endPt.y - startPt.y) * ratio + startPt.y
         Next Array Index newStroke()
         If Not Array Index Valid(newStroke()) Then Array Insert At Bottom newStroke()
         newStroke() = newPt                                   `And store that point
      Else
      `Not enough length yet, keep going through the points
         If NOT Array Index Valid(stroke()) Then Exit `If we've reached the end of our points, stop the loop
         startPt = endPt                              `The start Point is now the last End Point
         endPt = stroke()                             `Get the next Point
         Next Array Index stroke()                    `Go one forward in our stroke() List
         dx = endPt.x - startPt.x                     `Distance between points
         dy = endPt.y - startPt.y
         curSegmentLen = Sqrt((dx*dx) + (dy*dy))      `The distance from this new Start Point to the new End Point
         startOldDist = endOldDist                    `The distance so far up to the new 'Start Point'
         endOldDist = endOldDist + curSegmentLen      `The distance so far up to the new 'End Point'
      EndIf
   Next i
 
   `Floating point errors might mean we miss the last point
   `So, add in that point to the new List
   If Array Count(newStroke()) < pointsPerSrtoke
      Next Array Index newStroke()
      If Not Array Index Valid(newStroke()) Then Array Insert At Bottom newStroke()
      newStroke() = endPt
   EndIf
 
   Empty Array stroke()             `Empty the original List
   Array Insert At Bottom stroke()  `Add the first position
   Array Index To Top stroke()      `Point the index at it
   Array Index To Top newStroke()   `Reset the index of the new List
 
   While Array Index Valid(newStroke())
      stroke() = newStroke()           `Copy over the point
      Next Array Index stroke()        `Move along one in the List
      If Not Array Index Valid(stroke()) Then Array Insert At Bottom stroke() `Add a new element if need-be
      Next Array Index newStroke()
   EndWhile
 
EndFunction
 
 
Function normalizeCenter()
 
   centerX As Integer = 0
   centerY As Integer = 0
 
   If Array Count(stroke()) = 0 Then ExitFunction
 
   Array Index To Top stroke()
   While Array Index Valid(stroke())
      centerX = centerX + stroke().x
      centerY = centerY + stroke().y
      Next Array Index stroke()
   EndWhile
 
   centerX = centerX / Array Count(stroke())
   centerY = centerY / Array Count(stroke())
 
   Array Index To Top stroke()
   While Array Index Valid(stroke())
      stroke().x = stroke().x - centerX
      stroke().y = stroke().y - centerY
      Next Array Index stroke()
   EndWhile
 
EndFunction