Пример #1
0
        static TrigradCompressed fauxResults(PixelMap input)
        {
            var results = new TrigradCompressed();

            results.Width = input.Width;
            results.Height = input.Height;

            List<Point> samplePoints = new List<Point>();

            samplePoints.Add(new Point(0, 0));
            samplePoints.Add(new Point(input.Width - 1, 0));
            samplePoints.Add(new Point(0, input.Height - 1));
            samplePoints.Add(new Point(input.Width - 1, input.Height - 1));

            int cellsize = 8;

            for (int x = 0; x < input.Width / cellsize; x++)
            {
                for (int y = 0; y < input.Height / cellsize; y++)
                {
                    samplePoints.Add(new Point(x * cellsize, y * cellsize));
                }
            }

            foreach (var samplePoint in samplePoints)
            {
                results.SampleTable[samplePoint] = input[samplePoint];
            }

            results.Mesh = MeshBuilder.BuildMesh(results.SampleTable);

            return results;
        }
Пример #2
0
        /// <summary> Decompresses a trigrad compressed bitmap. </summary>
        /// <param name="compressionData"> The TrigradCompressed data.</param>
        /// <param name="original"> The original image to determine the most effect fill mode.</param>
        /// <param name="options"> Options dictating the decompression.</param>
        public static TrigradDecompressed DecompressBitmap(TrigradCompressed compressionData, TrigradOptions options)
        {
            TrigradDecompressed decompressed = new TrigradDecompressed(compressionData.Width, compressionData.Height);

            for (int x = 0; x < compressionData.Width; x++)
                for (int y = 0; y < compressionData.Height; y++)
                    decompressed.Output[x, y] = new Pixel(Color.HotPink);

            drawMesh(compressionData.Mesh, decompressed.Output, options);

            fillGaps(decompressed.Output);

            return decompressed;
        }
Пример #3
0
        public static void OptimiseMesh(TrigradCompressed compressionData, PixelMap original, TrigradOptions options)
        {
            var mesh = compressionData.Mesh;
            GPUT.CalculateMesh(mesh);

            var samples = mesh.SelectMany(t => t.Samples).Distinct().ToList();

            for (int i = 0; i < options.Iterations; i++)
            {
                minimiseMesh(samples, options, original);

                Console.WriteLine("{0}/{1}", i, options.Iterations);
            }

            compressionData.Mesh = mesh;
        }
Пример #4
0
        /// <summary> Compresses a bitmap using TrigradCompression. </summary>
        /// <param name="pixelmap"> The input bitmap.</param>
        /// <param name="options"> TrigradOptions specifying how the image will be compressed.</param>
        public static TrigradCompressed CompressBitmap(PixelMap pixelmap, TrigradOptions options)
        {
            TrigradCompressed compressed = new TrigradCompressed { Height = pixelmap.Height, Width = pixelmap.Width };

            double baseChance = options.SampleCount / (options.FrequencyTable.Sum);

            int i = 0;
            int count = pixelmap.Width * pixelmap.Height;
            for (int x = 0; x < pixelmap.Width; x++)
            {
                for (int y = 0; y < pixelmap.Height; y++)
                {
                    if ((x == 0 && y == 0) ||
                        (x == pixelmap.Width - 1 && y == 0) ||
                        (x == 0 && y == pixelmap.Height - 1) ||
                        (x == pixelmap.Width - 1 && y == pixelmap.Height - 1))
                    {
                        compressed.SampleTable[new Point(x, y)] = pixelmap[new Point(x, y)];
                        continue;
                    }

                    double chance = ((options.FrequencyTable != null)
                        ? options.FrequencyTable.Table[x, y]
                        : 1d) * baseChance;

                    lock(options.Random)
                    if (options.Random.NextDouble() < chance)
                    {
                        lock (compressed.SampleTable)
                            compressed.SampleTable[new Point(x, y)] = pixelmap[new Point(x, y)];
                    }

                    if (i % 50 == 0 && OnUpdate != null)
                        OnUpdate((double)i / count);

                    i++;
                }
            }

            return compressed;
        }