示例#1
0
        private void hfzWriteTile(ref EndianBinaryWriter writer, HfzHeader fh, HfzTile tile)
        {
            List<float> pTileData = tile.tileData;

            Int32 i=0, TempInt, FirstVal;
            float f, HFmin, HFmax, VertScale, VertOffset;
            sbyte c;
            short s;

            UInt32 nx = fh.nx;
            UInt32 ny = fh.ny;
            UInt32 TileSize = fh.TileSize;
            float Precis = fh.Precis;
            // get min/max alt in block (used for vert scale)
            HFmin = 0;
            HFmax = 0;
            Epsilon epsilon = new Epsilon(1E-3);

            for (i = 0; i < pTileData.Count; i++)
            {
                // find max diff in line

                f = pTileData.ElementAt(i);

                if (i == 0)
                {
                    HFmin = HFmax = f;
                }
                else
                {
                    if (RealExtensions.LT(f, HFmin, epsilon))
                    {
                        HFmin = f;
                    }

                    if (RealExtensions.GT(f, HFmax, epsilon))
                    {
                        HFmax = f;
                    }
                }
            }

            // number of int levels required for this block
            float BlockLevels = ((HFmax - HFmin) / Precis) + 1;

            // calc scale
            VertScale = (HFmax - HFmin) / BlockLevels;
            VertOffset = HFmin;
            if (RealExtensions.LE(VertScale, 0, epsilon))
            {
                VertScale = 1.0f; // this is for niceness
            }

            writer.Write(VertScale);
            writer.Write(VertOffset);

            // determine number of blocks
            Int32 nBlocksX = ((int)fh.nx / fh.TileSize) - 1;  // -1 due to index starting at 0
            Int32 exBlocksX = -1;
            Int32 nBlocksY = ((int)fh.ny / fh.TileSize) - 1;  // -1 due to index starting at 0
            Int32 exBlocksY = -1;

            if (fh.nx % fh.TileSize > 0)
            {
                exBlocksX = nBlocksX + 1;
            }

            if (fh.ny % fh.TileSize > 0)
            {
                exBlocksY = nBlocksY + 1;
            }

            UInt32 rows = TileSize;
            if(tile.x != exBlocksX && tile.y == exBlocksY || tile.x == exBlocksX && tile.y == exBlocksY)
            {
                rows = (uint)(TileSize - (((exBlocksY+1) * TileSize) - ny));
            }
            else if (tile.x == exBlocksX && tile.y != exBlocksY)
            {
                rows = calculateRows(tile, ny, TileSize, rows);
            }

            int rowCount = 0;
            int rowZeroElement = 0;
            try
            {
                for (rowCount = 0; rowCount < rows; rowCount++)
                {
                    List<float> row = null;

                    int range = calculateRange(tile, nx, TileSize);

                    rowZeroElement = (int)(rowCount * range);
                    row = pTileData.GetRange(rowZeroElement, range);

                    f = row.ElementAt(0);
                    FirstVal = Convert.ToInt32(Math.Truncate((f - VertOffset) / VertScale));
                    Int32 LastVal = FirstVal;

                    // find max diff in line
                    Int32 Diff;
                    Int32 MaxDev = 0;
                    List<Int32> pDiffBuf = new List<Int32>();
                    for (int rowElementCounter = 1; rowElementCounter < row.Count; rowElementCounter++)
                    {

                        // find max diff in line
                        f = row.ElementAt(rowElementCounter);
                        TempInt = Convert.ToInt32(Math.Truncate((f - VertOffset) / VertScale));
                        Diff = TempInt - LastVal;

                        pDiffBuf.Add(Diff);
                        LastVal = TempInt;
                        MaxDev = MaxDev > Math.Abs(Diff) ? MaxDev : Math.Abs(Diff);
                    }

                    // should we use 8, 16 or 32 bit pixels?
                    byte LineDepth = 4;
                    if (MaxDev <= 127)
                    {
                        LineDepth = 1;
                    }
                    else
                        if (MaxDev <= 32767)
                        {
                            LineDepth = 2;
                        }

                    writer.Write(LineDepth);
                    writer.Write(FirstVal);

                    for (int rowElementCounter = 0; rowElementCounter < pDiffBuf.Count; rowElementCounter++)
                    {
                        Diff = pDiffBuf.ElementAt(rowElementCounter);
                        switch (LineDepth)
                        {
                            case 1:
                                c = Convert.ToSByte(Diff);
                                writer.Write(c);
                                break;
                            case 2:
                                s = Convert.ToInt16(Diff);
                                writer.Write(s);
                                break;
                            case 4:
                                writer.Write(Diff);
                                break;
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                System.Console.WriteLine("Tile x :" + tile.x);
                System.Console.WriteLine("Tile y :" + tile.y);
                System.Console.WriteLine("Rows :" + rows);
                System.Console.WriteLine("RowCount :" + rowCount);
                System.Console.WriteLine("RowZeroElement :" + rowZeroElement);
                System.Console.WriteLine("exBlocksX :" + exBlocksX);
                System.Console.WriteLine("exBlocksY :" + exBlocksY);
                System.Console.WriteLine("pTileData count :" + pTileData.Count);
                throw ex;
            }
        }
示例#2
0
        private Dictionary<short, HfzTile> readTiles(HfzHeader header, EndianBinaryReader reader)
        {
            // I know this is offensive but after all the headaches this gave me IT'S STAYING IN !
            Boolean extraTileBullshit = false;
            UInt32 nx = header.nx;
            UInt32 ny = header.ny;

            debugLine("nx " + nx);
            debugLine("ny " + ny);

            ushort TileSize = header.TileSize;

            // determine number of blocks
            UInt32 nBlocksX = nx / TileSize;
            UInt32 nBlocksY = ny / TileSize;
            if (nx % TileSize != 0)
            {
                nBlocksX++;
                extraTileBullshit = true;
            }

            if (ny % TileSize != 0)
            {
                nBlocksY++;
                extraTileBullshit = true;
            }

            debugLine("x: " + nBlocksX + ", y: " + nBlocksY + ", extraTileBullshit: " + extraTileBullshit);

            short nTile = 0;
            Dictionary<short, HfzTile> tiles = new Dictionary<short, HfzTile>();
            for (UInt32 yAxis = 0; yAxis < nBlocksY; yAxis++)
            {
                for (UInt32 xAxis = 0; xAxis < nBlocksX; xAxis++)
                {
                    tiles.Add(nTile, hfzReadTile(reader, header, xAxis, yAxis, extraTileBullshit));
                    nTile++;
                }
            }

            return tiles;
        }
示例#3
0
        private void hfzWriteHeader(ref EndianBinaryWriter writer, HfzHeader fh)
        {
            // copy header into buffer
            writer.Write(Util.StringToByteArray("HF2", 4));
            writer.Write(fh.FileVersionNo);
            writer.Write(fh.nx);
            writer.Write(fh.ny);
            writer.Write(fh.TileSize);
            writer.Write(fh.Precis);
            writer.Write(fh.HorizScale);
            writer.Write(fh.countExtLength());

            // put extended header into a buffer
            hfzHeader_EncodeExtHeaderBuf(fh, ref writer);
        }
示例#4
0
        private HfzTile hfzReadTile(EndianBinaryReader reader, HfzHeader fh, UInt32 TileX, UInt32 TileY, Boolean extraPixelBullshit)
        {
            debugLine("TileX: "+ TileX +", TileY: " + TileY);
            List<float> pTileData = new List<float>();
            UInt32 i = 0, j = 0;

            UInt32 TileSize = fh.TileSize;
            UInt32 mapWidth = fh.nx;
            UInt32 mapHeight = fh.ny;
            UInt32 Rows = TileSize;
            UInt32 RowSize = TileSize-1;

            if (extraPixelBullshit)
            {
                Epsilon e = new Epsilon(1E-3);
                if (RealExtensions.EQ(TileX, (mapWidth / TileSize), e))
                {
                    debugLine("Entering X on " + TileX + "," + TileY);
                    debugLine("result: " + (TileSize - (((TileX + 1) * TileSize) - mapWidth)));
                    Rows = TileSize;
                    RowSize = (TileSize - (((TileX + 1) * TileSize) - mapWidth)) - 1;
                }

                if (RealExtensions.EQ(TileY, (mapHeight / TileSize), e))
                {
                    debugLine("Entering Y on " + TileX + "," + TileY);
                    debugLine("result: " + (TileSize - (((TileY + 1) * TileSize) - mapHeight)));
                    Rows =  TileSize - (((TileY + 1) * TileSize) - mapHeight);
                    RowSize = TileSize - 1;
                }

                if (RealExtensions.EQ(TileX, (mapWidth / TileSize), e) && RealExtensions.EQ(TileY, (mapHeight / TileSize), e))
                {
                    debugLine("Entering X,Y on " + TileX + "," + TileY);
                    debugLine("result: " + (TileSize - (((TileY + 1) * TileSize) - mapHeight)));
                    debugLine("result: " + ((TileSize - (((TileX + 1) * TileSize) - mapWidth)) - 1));
                    Rows = TileSize - (((TileY + 1) * TileSize) - mapHeight);
                    RowSize = (TileSize - (((TileX + 1) * TileSize) - mapWidth)) - 1;
                }
            }

            // read vert offset and sale
            byte LineDepth = 0;
            Int32 FirstVal = 0;
            int tileValues = 0;
            int firstValues = 0;
            try
            {
                float VertScale = reader.ReadSingle();
                float VertOffset = reader.ReadSingle();

                for (j = 0; j < Rows; j++)
                {
                    LineDepth = reader.ReadByte(); // 1, 2, or 4
                    debugLine("Linedepth " + LineDepth);
                    FirstVal = reader.ReadInt32();
                    debugLine("FirstVal " + FirstVal);
                    tileValues++;
                    firstValues++;

                    float pixelValue = (float)FirstVal * VertScale + VertOffset;

                    // set first pixel
                    pTileData.Add(pixelValue);
                    debugLine("FirstValue: " + pixelValue);

                    Int32 LastVal = FirstVal;
                    Int32 li;

                    for (i = 0; i < RowSize; i++)
                    {
                        switch (LineDepth)
                        {
                            case 1:
                                sbyte bvalue = reader.ReadSByte();
                                li = (Int32)bvalue;
                                break;
                            case 2:
                                short svalue = reader.ReadInt16();
                                li = (Int32)svalue;
                                break;
                            default:
                                li = reader.ReadInt32();
                                break;
                        }

                        pixelValue = (float)(li + LastVal) * VertScale + VertOffset;
                        LastVal = li + LastVal;

                        pTileData.Add(pixelValue);
                        tileValues++;
                        debugLine("v: " + pixelValue);
                    }
                }
                debugLine("TileValues: " + tileValues);
                debugLine("FirstValues: " + firstValues);
            }
            catch (Exception)
            {
                System.Console.WriteLine("TileSize: " + TileSize);
                System.Console.WriteLine("x: " + TileX);
                System.Console.WriteLine("y: " + TileY);
                System.Console.WriteLine("j: " + j);
                System.Console.WriteLine("i: " + i);
                System.Console.WriteLine("LineDepth: " + LineDepth);
                System.Console.WriteLine("FirstVal: " + FirstVal);
                throw;
            }
            debugLine("total tilevalues " + tileValues);
            debugLine("total firstvalues " + firstValues);
            return new HfzTile(TileX, TileY, RowSize+1, Rows, pTileData);
        }
示例#5
0
        private HfzHeader hfzReadHeader(EndianBinaryReader reader)
        {
            HfzHeader fh = new HfzHeader();

            string heading = UTF8Encoding.UTF8.GetString(reader.ReadBytes(4));
            if (heading.Equals("HF2"))
            {
                throw new Exception("Invalid file format heading HF2 not found");
            }

            ushort fileVersion = reader.ReadUInt16();
            fh.FileVersionNo = fileVersion;

            UInt32 nx = reader.ReadUInt32();
            fh.nx = nx;

            UInt32 ny = reader.ReadUInt32();
            fh.ny = ny;

            ushort tileSize = reader.ReadUInt16();
            fh.TileSize = tileSize;

            float Precis = reader.ReadSingle();
            fh.Precis = Precis;

            float HorizScale = reader.ReadSingle();
            fh.HorizScale = HorizScale;

            UInt32 ExtHeaderLength = reader.ReadUInt32();
            fh.ExtHeaderLength = ExtHeaderLength;

            if (ExtHeaderLength > 0)
            {
                fh = decodeExtHeaderBuf(fh, reader);
            }

            return fh;
        }
示例#6
0
        private void hfzHeader_EncodeExtHeaderBuf(HfzHeader fh, ref EndianBinaryWriter writer)
        {
            if (fh.nExtHeaderBlocks == 0)
            {
                return;
            }

            if (fh.countExtLength() == 0)
            {
                // can't have zero length
                throw new Exception("Can't have a extended header of zero size");
            }

            HfzExtHeaderBlock pBlock;
            for (int i = 0; i < fh.nExtHeaderBlocks; i++)
            {
                pBlock = fh.pExtHeaderBlocks.ElementAt(i);

                writer.Write(Util.StringToByteArray(pBlock.BlockType, 4));
                writer.Write(Util.StringToByteArray(pBlock.BlockName, 16));
                writer.Write(pBlock.BlockLength);

                if (pBlock.BlockLength > 0)
                {
                    writer.Write(pBlock.pBlockData);
                }
            }
        }
示例#7
0
        private HfzHeader decodeExtHeaderBuf(HfzHeader fh, EndianBinaryReader reader)
        {
            if (fh.ExtHeaderLength == 0)
            {
                return fh;
            }

            fh.nExtHeaderBlocks = 0;
            fh.pExtHeaderBlocks = new List<HfzExtHeaderBlock>();

            // read once to determine number of blocks
            bool DoneFlag = false;
            int offset = 0;
            do
            {
                if (offset == fh.ExtHeaderLength)
                {
                    DoneFlag = true;
                }
                else if (fh.ExtHeaderLength - offset < 24)
                {
                    // not enough for a complete header
                    throw new Exception("Not enough bytes for a full extended header found.  Header size: " + fh.ExtHeaderLength);
                }
                else
                {
                    string blockType = UTF8Encoding.UTF8.GetString(reader.ReadBytes(4));
                    string blockName = UTF8Encoding.UTF8.GetString(reader.ReadBytes(16));
                    UInt32 blockLength = reader.ReadUInt32();
                    byte[] data = reader.ReadBytes((int)blockLength);

                    HfzExtHeaderBlock block = new HfzExtHeaderBlock(blockType, blockName, blockLength, data);
                    fh.pExtHeaderBlocks.Add(block);

                    fh.nExtHeaderBlocks = fh.nExtHeaderBlocks + 1;
                    offset = offset + 24 + (int)block.BlockLength;
                }
            } while (!DoneFlag);

            return fh;
        }