Beispiel #1
0
        /**
         * Helper method loads the next character data into the given CharacterDescriptor
         * from the given DataInputStream as formatted by a strokes data file.
         *
         * @param loadInto the CharacterDescriptor instance to load data into
         * @param dataStream the stream to load data from
         * @throws IOException
         */
        private void loadNextCharacterDataFromStream(CharacterDescriptor loadInto)
        {
            char character     = (char)strokeDataStream.ReadInt16(); // character is the first two bytes
            int  characterType = (int)strokeDataStream.ReadByte();   // character type is the first byte
            int  strokeCount   = (int)strokeDataStream.ReadByte();   // number of strokes is next
            // the number of strokes is deducible from
            // where we are in the stream, but the stream
            // wasn't originally ordered by stroke count...

            int subStrokeCount = 0;

            double[] directions = loadInto.Directions;
            double[] lengths    = loadInto.Lengths;

            // format of substroke data is [sub stroke count per stroke]([direction][length])+
            // there will be a direction,length pair for each of the substrokes
            for (int i = 0; i < strokeCount; i++)
            {
                // for each stroke

                // read the number of sub strokes in the stroke
                int numSubStrokesInStroke = (int)strokeDataStream.ReadByte();

                for (int j = 0; j < numSubStrokesInStroke; j++)
                {
                    // for each sub stroke read out the direction and length

                    double direction = StrokesIO.ReadDirection(strokeDataStream);
                    double length    = StrokesIO.ReadLength(strokeDataStream);

                    directions[subStrokeCount] = direction;
                    lengths[subStrokeCount]    = length;

                    subStrokeCount++;
                }
            }

            loadInto.Character      = character;
            loadInto.CharacterType  = characterType;
            loadInto.StrokeCount    = strokeCount;
            loadInto.SubStrokeCount = subStrokeCount;
        }
Beispiel #2
0
        /**
         * Writes the entry into the strokes byte array.
         * Entries are written one after another.  There are no delimiting tokens.
         * The format of an entry in the byte array is as follows:
         *
         * 2 bytes for the character
         * 1 byte for the type (generic, traditional, simplified)
         *
         * 1 byte for the number of Strokes
         * 1 byte for the number of SubStrokes
         * Because of the above, maximum number of Strokes/SubStrokes is 2^7 - 1 = 127.
         * This should definitely be enough for Strokes, probably enough for SubStrokes.
         * In any case, this limitation is less than the limitation imposed by the defined constants currently.
         *
         * Then for each Stroke:
         * 1 byte for the number of SubStrokes in the Stroke
         *
         * Then for each SubStroke:
         * 2 bytes for direction
         * 2 bytes for length
         *
         * Could probably get by with 1 byte for number of Strokes and SubStrokes if needed.
         * Any change to this method will need to be matched by changes to StrokesRepository#compareToNextInStream.
         *
         * @param character the Character that this entry is for
         * @param type the type of the Character (generic, traditiona, simplified, should be one of the constants)
         * @param strokeCount the number of Strokes in this Character entry
         * @param subStrokeCount the number of SubStrokes in this Character entry.
         */
        private void writeStrokeData(BinaryWriter dataOut, char character, int type, int strokeCount, int subStrokeCount)
        {
            // Write out the non-SubStroke data.
            dataOut.Write((short)character);
            dataOut.Write((byte)type);
            dataOut.Write((byte)strokeCount);

            int subStrokeArrayIndex = 0;

            for (int strokes = 0; strokes < strokeCount; strokes++)
            {
                int numSubStrokeForStroke = this.subStrokesPerStroke[strokes];

                //  Write out the number of SubStrokes in this Stroke.
                dataOut.Write((byte)numSubStrokeForStroke);

                for (int substrokes = 0; substrokes < numSubStrokeForStroke; substrokes++)
                {
                    StrokesIO.WriteDirection(this.subStrokeDirections[subStrokeArrayIndex], dataOut);
                    StrokesIO.WriteLength(this.subStrokeLengths[subStrokeArrayIndex], dataOut);
                    subStrokeArrayIndex++;
                }
            }
        }