Braille.frink

View or download Braille.frink in plain text format


// This is a library that converts text to Braille.
//
class Braille
{
   // A dictionary mapping single characters to their braille Unicode
   // equivalent.
   class var charDict = undef

   // An inverse dictionary mapping Unicode characters to their ASCII
   // equivalents
   class var reverseDict = undef

   // Nominal base diameter of braille dots.
   class var DOT_DIAMETER = 0.057 in

   // Nominal distance from center to center of adjacent dots in the same
   // cell.
   class var DOT_SPACING = 0.092 in

   // Nominal horizontal distance between corresponding dots in two cells
   // horizontally (empirically found to match my braille template.)
   class var INTERCHAR_HORIZONTAL_SPACING = 0.241589 in

   // Nominal vertical distance between corresponding dots in two cells
   class var INTERLINE_SPACING = 0.4 in
   
   // Initialize the character dictionaries.
   class initDict[] :=
   {
      charDict = new dict
      charDict@"a" = "\u2801"
      charDict@"b" = "\u2803"
      charDict@"c" = "\u2809"
      charDict@"d" = "\u2819"
      charDict@"e" = "\u2811"
      charDict@"f" = "\u280b"
      charDict@"g" = "\u281b"
      charDict@"h" = "\u2813"
      charDict@"i" = "\u280a"
      charDict@"j" = "\u281a"
      charDict@"k" = "\u2805"
      charDict@"l" = "\u2807"
      charDict@"m" = "\u280d"
      charDict@"n" = "\u281d"
      charDict@"o" = "\u2815"
      charDict@"p" = "\u280f"
      charDict@"q" = "\u281f"
      charDict@"r" = "\u2817"
      charDict@"s" = "\u280e"
      charDict@"t" = "\u281e"
      charDict@"u" = "\u2825"
      charDict@"v" = "\u2827"
      charDict@"w" = "\u283a"
      charDict@"x" = "\u282d"
      charDict@"y" = "\u283d"
      charDict@"z" = "\u2835"

      charDict@"?" = "\u2826"
      charDict@"," = "\u2802"
      charDict@";" = "\u2806"
      charDict@":" = "\u2812"
      charDict@"." = "\u2832"
      charDict@"!" = "\u2816"
      charDict@"-" = "\u2824"

      // We invert here because numbers and letters use the same symbols.
      reverseDict = charDict.invert[]
      
      charDict@"1" = "\u2801"
      charDict@"2" = "\u2803"
      charDict@"3" = "\u2809"
      charDict@"4" = "\u2819"
      charDict@"5" = "\u2811"
      charDict@"6" = "\u280b"
      charDict@"7" = "\u281b"
      charDict@"8" = "\u2813"
      charDict@"9" = "\u280a"
      charDict@"0" = "\u281a"
      
   }

   // Convert the specified string to its Braille unicode equivalent.
   // This just uses Braille grade 1 transformations.
   class toBrailleGrade1[str] :=
   {
      if charDict == undef
         initDict[]

      result = ""

      // Collapse multiple spaces into one.
      str =~ %s/([\s]+)/ /g

      // Add number sign before numbers
      str =~ %s/([0-9]+)/\u283c$1/g;

      // Add capitalization mark for next character.
      str =~ %s/([A-Z])/"\u2820" + lc[$1]/ge;
      
      for c = charList[str]
      {
         if charDict.containsKey[c]
            result = result + charDict@c
         else
            result = result + c
      }

      return result
   }


   // Draw a block of text in braille, wrapping it to fit the specified maximum
   // width.
   //
   // Parameters:
   //  g : an object of type graphics that will be drawn to.
   //  str: The string to draw.  If it is not already converted to Unicode
   //       representation, it will be automatically converted.
   //  x,y:  The coordinates where drawing is to begin (must have dimensions
   //        of length (e.g. "0 mm, 0 mm") unless you redefine the spacing
   //        constants.
   //  maxWidth:  The maximum width to draw before wrapping.  Should have
   //        dimensions of width unless you redefine the spacing constants.
   //        If this is undef, then no wrapping will be performed.
   //  hDirection:  Should be 1 for drawing normally.  To draw horizontally
   //        mirrored (so you can print on the back of the paper and punch
   //        through it,) this should be -1.
   //  fill:  true if the dots are to be filled.  If false, only the outline
   //        of the dot will be drawn.
   //  diam:  The diameter of each dot.
   //  dotSpace:  The distance between two dots in a character.
   //  horizSpace: The horizontal distance between corresponding dots in two
   //         different characters.
   //  lineSpace:  The vertical distance between corresponding dots in two
   //         different lines of text.
   //
   //  Spacing constants follow standard sizes for printed braille.
   //
   class drawText[g is graphics, str, x, y, maxWidth=undef, hDirection = 1, fill=true, diam = Braille.DOT_DIAMETER, dotSpace = Braille.DOT_SPACING, horizSpace = Braille.INTERCHAR_HORIZONTAL_SPACING, lineSpace = Braille.INTERLINE_SPACING] :=
   {
      if ! isEncoded[str]
         str = toBrailleGrade1[str]
      
      if maxWidth == undef
         drawLine[g, str, x, y, hDirection, fill, diam, dotSpace, horizSpace]
      else
      {
         maxChars = maxWidth div horizSpace
//         println["maxChars is $maxChars"]
         startPos = 0
         length = length[str]
         endPos = min[startPos + maxChars - 1, length]
         while startPos < length
         {
            while (endPos >= startPos)
            {
               if substrLen[str, endPos, 1] == " "
               {
                  text = substr[str, startPos, endPos]
//                  println[text]
                  drawLine[g, text, x, y, hDirection, fill, diam, dotSpace, horizSpace]
                  y = y + lineSpace
                  startPos = endPos + 1
                  endPos = min[startPos + maxChars - 1, length]
               } else
               endPos = endPos - 1
            }

            if (endPos == startPos-1) // Didn't find a space
            {
               text = substrLen[str, startPos, maxChars]
//               println[text]
               drawLine[g, text, x, y, hDirection, fill, diam, dotSpace, horizSpace]
               y = y + lineSpace
               startPos = startPos + maxChars
               endPos = min[startPos + maxChars-1, length]
            }
         }
      }
   }

   // Draws a line of text in Braille.  You probably shouldn't call this
   // method directly, but rather call drawText which performs the appropriate
   // wrapping and encoding.
   class drawLine[g is graphics, str, x, y, hDirection = 1, fill=true, diam = Braille.DOT_DIAMETER, dotSpace = Braille.DOT_SPACING, horizSpace = Braille.INTERCHAR_HORIZONTAL_SPACING] :=
   {
      x = x + hDirection * (horizSpace - dotSpace)/2      // Center in space
      for c = charList[str]
      {
         drawChar[g, c, x, y, hDirection, fill, diam, dotSpace, horizSpace]
         x = x + horizSpace * hDirection
      }
   }

   // Draws a single braille character.
   class drawChar[g is graphics, char, x, y, hDirection = 1, fill = true, diam = Braille.DOT_DIAMETER, dotSpace = Braille.DOT_SPACING, horizSpace = Braille.INTERCHAR_HORIZONTAL_SPACING] :=
   {
      c = char[char]
      if c >= 0x2800 and c <= 0x28FF
      {
         c = c - 0x2800
         if getBit[c, 0] == 1
            drawDot[g, x, y, fill, diam]
         if getBit[c, 1] == 1
            drawDot[g, x, y+dotSpace, fill, diam]
         if getBit[c, 2] == 1
            drawDot[g, x, y+dotSpace*2, fill, diam]
         if getBit[c, 3] == 1
            drawDot[g, x+dotSpace*hDirection, y, fill, diam]
         if getBit[c, 4] == 1
            drawDot[g, x+dotSpace*hDirection, y+dotSpace, fill, diam]
         if getBit[c, 5] == 1
            drawDot[g, x+dotSpace*hDirection, y+dotSpace*2, fill, diam]
         if getBit[c, 6] == 1
            drawDot[g, x, y+dotSpace*3, fill, diam]
         if getBit[c, 7] == 1
            drawDot[g, x+dotSpace*hDirection, y+dotSpace*3, fill, diam]
      }
   }

   // Draw a single dot centered at the specified location.
   class drawDot[g is graphics, x, y, fill=true, diam = Braille.DOT_DIAMETER] :=
   {
      if fill
         g.fillEllipseCenter[x, y, diam, diam]
      else
         g.drawEllipseCenter[x, y, diam, diam]
   }

   // Returns true if the string is already encoded into Braille, (that is,
   // if it contains any Braille Unicode characters at all.)
   class isEncoded[str] :=
   {
      for c = chars[str]
         if c >= 0x2800 and c <= 0x28ff
            return true

      return false       
   }

   // This reverses 
   class fromUnicodeBraille[str] :=
   {
      result = ""
      
      if charDict == undef
         initDict[]

      for c = charList[str]
         if reverseDict@c == undef
            result = result + c
         else
            result = result + reverseDict@c

      return result      
   }
}


View or download Braille.frink in plain text format


This is a program written in the programming language Frink.
For more information, view the Frink Documentation or see More Sample Frink Programs.

Alan Eliasen was born 17959 days, 14 hours, 15 minutes ago.