static void Experiment5Taskv2Performence()
{
int level = 2;
string name = "lenna";
Logger.Info(name);
string inputName = $"../../../test_images/{name}.png";
Bitmap input = new Bitmap(inputName);
Bitmap output = new Bitmap(input.Width, input.Height, input.PixelFormat);
var imageReader = new BitmapReader <int>(input);
var mallat = new MallatDecomposition <int, NineSevenBiortogonalInteger <int> >(imageReader).Build(input.Size, level);
Logger.Info(mallat.ToString());
var calculator = new MallatEntropyEvaluator <int>(input.Size, level, mallat);
var mallatCollector = new MallatMerger <int>(input.Size, level, mallat);
var imageWriter = new BitmapWriter <int>(new Bitmap(input.Width, input.Height, System.Drawing.Imaging.PixelFormat.Format32bppRgb), "", mallatCollector);
string outputName = $"{inputName}_{mallat.ToString()}.png";
imageWriter.SetImageName(outputName);
calculator.DataLength = 3;
var sw = System.Diagnostics.Stopwatch.StartNew();
Logger.Info("Sync:");
imageWriter.Process();
Logger.Info($"Time:\t{sw.Elapsed}");
sw.Restart();
Logger.Info("Async v2:");
imageWriter.ProcessAsync();
Logger.Info($"Time:\t{sw.Elapsed}");
}
public FileDisplay(string filename)
{
this.filename = filename == null ? "output.png" : filename;
string extension = FileUtils.getExtension(filename);
writer = PluginRegistry.bitmapWriterPlugins.createObject(extension);
}
static void TesterParameterDemo()
{
string inputName = "../../../test_images/lenna.png";
Bitmap input = new Bitmap(inputName);
var imageReader = new BitmapReader <float>(input);
var mallat = new MallatDecomposition <float, Haar <float> >(imageReader).Build(input.Size, 1);
var imageWriter = new BitmapWriter <float>(new Bitmap(input.Size.Width, input.Size.Height), "", mallat);
var tester = new ParameterTester <float>(imageWriter)
.SetNextParameters(new ParameterStorage().SetParameter("outputName", "../lenna_1.png"))
.SetNextParameters(new ParameterStorage().SetParameter("outputName", "../lenna_2.png"))
.SetNextParameters(new ParameterStorage().SetParameter("outputName", "../lenna_3.png"));
tester.RunSync();
}
public string Execute()
{
string result = string.Empty;
if (_images.Any())
{
var baseFileName = GetSuitableFilenameWithoutExtension(_scriptureText);
if (_images.Count == 1)
{
var path = Path.Combine(_folder, Path.ChangeExtension(baseFileName, ".png"));
BitmapWriter.WritePng(path, _images.First());
result = path;
}
else
{
string folder = Path.Combine(_folder, baseFileName);
if (Directory.Exists(folder))
{
ClearFiles(folder);
}
else
{
Directory.CreateDirectory(folder);
}
if (Directory.Exists(folder))
{
if (Directory.EnumerateFiles(folder).Any())
{
throw new Exception("Could not clear folder!");
}
result = folder;
int count = 1;
foreach (var image in _images)
{
var baseNameWithDigitPrefix = $"{count:D3} {baseFileName}";
var path = Path.Combine(folder, Path.ChangeExtension(baseNameWithDigitPrefix, ".png"));
BitmapWriter.WritePng(path, image);
++count;
}
}
}
}
return(result);
}
static void Experiment7()
{
string name = "barbara";
string folder = "../../../test_images";
string inputName = $"{folder}/{name}.png";
Logger.Info(inputName);
Bitmap input = new Bitmap(inputName);
Bitmap output1 = new Bitmap(input.Width / 2, input.Height, input.PixelFormat);
Bitmap output2 = new Bitmap(input.Width / 2, input.Height, input.PixelFormat);
var imageReader = new BitmapReader <int>(input);
var d4 = new DaubechiesWaveletD4Integer <int>(imageReader);
var imageWriter1 = new BitmapWriter <int>(output1, $"{folder}/Experiment7_barbara_0.png", d4[0]);
var imageWriter2 = new BitmapWriter <int>(output1, $"{folder}/Experiment7_barbara_1.png", d4[1]);
imageWriter1.ProcessAsync();
imageWriter2.ProcessAsync();
}
public void save(string filename)
{
string extension = FileUtils.getExtension(filename);
BitmapWriter writer = PluginRegistry.bitmapWriterPlugins.createObject(extension);
if (writer == null)
{
UI.printError(UI.Module.IMG, "Unable to save file \"{0}\" - unknown file format: {1}", filename, extension);
return;
}
try {
writer.openFile(filename);
writer.writeHeader(w, h, Math.Max(w, h));
writer.writeTile(0, 0, w, h, color, alpha);
writer.closeFile();
} catch (IOException e) {
UI.printError(UI.Module.IMG, "Unable to save file \"{0}\" - {1}", filename, e.Message);
}
}
public void WriteTest()
{
var bitmap = (Bitmap)Image.FromFile(".\\Evic11_0x2FC1.bmp");
byte[] actual = null;
byte[] expected = null;
using (var fileStream = new FileStream("Evic11.dec", FileMode.Open, FileAccess.Read))
using (var memoryStream = new MemoryStream(new byte[fileStream.Length]))
{
fileStream.CopyTo(memoryStream);
var bitmapWriter = new BitmapWriter();
bitmapWriter.Write(memoryStream, 0x2FC1, bitmap);
actual = memoryStream.ToArray();
expected = new byte[fileStream.Length];
fileStream.Seek(0, SeekOrigin.Begin);
fileStream.Read(expected, 0, expected.Length);
}
CollectionAssert.AreEquivalent(expected, actual);
}
static void ExperimentEntropy(string name, int level)
{
string folder = "../../../test_images";
string inputName = $"{folder}/{name}.png";
Logger.Info(inputName);
Bitmap input = new Bitmap(inputName);
Bitmap output = new Bitmap(input.Width, input.Height, input.PixelFormat);
var tester = new MallatTester <int>((GetMallat) =>
{
var imageReader = new BitmapReader <int>(input);
var mallat = GetMallat(imageReader);
Logger.Info(mallat.ToString());
var calculator = new MallatEntropyEvaluator <int>(input.Size, level, (Segment <int>)mallat);
var mallatCollector = new MallatMerger <int>(input.Size, level, (Segment <int>)mallat);
var imageWriter = new BitmapWriter <int>(new Bitmap(input.Width, input.Height, System.Drawing.Imaging.PixelFormat.Format32bppArgb), "", mallatCollector);
string outputName = $"{folder}/{level}/{name}_{mallat.ToString()}.png";
imageWriter.SetImageName(outputName);
calculator.DataLength = 3;
return(new Node <int>[] { imageWriter, calculator });
});
tester.AddNewMallat((predecessor) => { return(new MallatDecomposition <int, TwoTwoInterpolatingInteger <int> >(predecessor).Build(input.Size, level)); });
tester.AddNewMallat((predecessor) => { return(new MallatDecomposition <int, FourTwoInterpolatingInteger <int> >(predecessor).Build(input.Size, level)); });
tester.AddNewMallat((predecessor) => { return(new MallatDecomposition <int, TwoFourInterpolatingInteger <int> >(predecessor).Build(input.Size, level)); });
tester.AddNewMallat((predecessor) => { return(new MallatDecomposition <int, FourFourInterpolatingInteger <int> >(predecessor).Build(input.Size, level)); });
tester.AddNewMallat((predecessor) => { return(new MallatDecomposition <int, TwoPlusTwoTwoInteger <int> >(predecessor).Build(input.Size, level)); });
tester.AddNewMallat((predecessor) => { return(new MallatDecomposition <int, DaubechiesWaveletD4Integer <int> >(predecessor).Build(input.Size, level)); });
tester.AddNewMallat((predecessor) => { return(new MallatDecomposition <int, NineSevenBiortogonalInteger <int> >(predecessor).Build(input.Size, level)); });
tester.AddNewMallat((predecessor) => { return(new MallatDecomposition <int, BaseWavelet <int> >(predecessor).Build(input.Size, level)); });
var sw = System.Diagnostics.Stopwatch.StartNew();
tester.RunAsync();
Logger.Info($"Time:\t{sw.Elapsed}");
}
public void Create(
string themePath,
OnlyVTheme theme,
BitmapImage backgroundImage,
bool overwrite)
{
string backgroundImagePath = null;
if (backgroundImage != null)
{
backgroundImagePath = Path.GetRandomFileName();
backgroundImagePath = Path.ChangeExtension(backgroundImagePath, ".png");
backgroundImagePath = Path.Combine(Path.GetTempPath(), backgroundImagePath);
BitmapWriter.WritePng(backgroundImagePath, backgroundImage);
}
Create(themePath, theme, backgroundImagePath, overwrite);
if (backgroundImagePath != null)
{
File.Delete(backgroundImagePath);
}
}
static void WriteTextures(BinaryWriter bw)
{
bw.Write((int)PartToolsLib.EntryType.Textures);
bw.Write(textures.Count);
for (int i = 0; i < textures.Count; i++)
{
if (textures[i] == null)
{
Debug.LogError(i);
bw.Write(" ");
bw.Write((int)PartToolsLib.TextureType.Texture);
}
else
{
string name = textures[i].texture.name;
if (copyTexturesToTargetDir)
{
string path = AssetDatabase.GetAssetPath(textures[i].texture);
string texExt = (path.Substring(path.LastIndexOf('.') + 1)).ToLower();
if (convertTextures)
{
name = filename + i.ToString("D3") + "." + textureFileExtension;
Debug.Log("Texture: '" + path + "' >> '" + name + "'");
BitmapWriter.Write2D(textures[i].texture, filePath + name, textures[i].type);
}
else
{
if (renameTextures)
{
name = filename + i.ToString("D3") + "." + texExt;
}
else
{
name = name + "." + texExt;
}
Debug.Log("Texture: '" + path + "' >> '" + name + "'");
AssetDatabase.CopyAsset(path, filePath + name);
if (textures[i].type == PartToolsLib.TextureType.NormalMap)
{
// check if we need to create a normal map from the texture
TextureImporter textureImporter = AssetImporter.GetAtPath(path) as TextureImporter;
if (textureImporter.convertToNormalmap)
{
Debug.Log("Converting '" + (filePath + name) + "' to a normal map");
// we do. make it so
ConvertNormalTexture(filePath + name, textureImporter.heightmapScale);
}
}
}
}
bw.Write(name);
bw.Write((int)textures[i].type);
}
}
}
public FileDisplay(string filename)
{
this.filename = filename == null ? "output.png" : filename;
string extension = FileUtils.getExtension(filename);
writer = PluginRegistry.bitmapWriterPlugins.createObject(extension);
}
private ColorRange[] Render()
{
this.edges.Sort();
var writer = new BitmapWriter(BackgroundColor, width, height);
var superSampleBuffer = new SuperSampleBuffer(width);
var layers = new LayerManager[SuperSampling.SamplesPerPixelY];
var superSampleRanges = new SuperSampleRangeList();
// Keeps track of how many of the subpixellayers that are used for
// the currently rendered scanline. Until a range requiring supersampling
// is encountered only a single layer is needed.
var usedLayers = 0;
var color = default(Color);
var intersections = new IntersectionList();
// Create a layer manager for every subpixel scanline
for (var i = 0; i < layers.Length; i++)
{
layers[i] = new LayerManager();
}
for (var ey = 0; ey < height; ey++)
{
var ranges = this.edges[ey];
if (ranges.Count == 0)
{
writer.Skip(width);
continue;
}
for (var i = 0; i < usedLayers; i++)
{
layers[i].Clear();
}
usedLayers = 1;
superSampleRanges.Populate(ranges);
writer.Skip(superSampleRanges[0].FromX);
for (var rangeIndex = 0; rangeIndex < superSampleRanges.Count; rangeIndex++)
{
ref var superSampleRange = ref superSampleRanges[rangeIndex];
// If there is exactly one edge in the supersample range, and it is crossing
// the entire scanline, we can perform the antialiasing by integrating the
// edge function.
if (superSampleRange.Count == 1 && (
superSampleRange[0].From.Y <= ey && superSampleRange[0].To.Y >= ey + 1 ||
superSampleRange[0].From.Y >= ey + 1 && superSampleRange[0].To.Y <= ey
))
{
var edge = superSampleRange[0];
// Determine the lower and upper x value where the edge
// intersects the scanline.
var xey = edge.Intersection(ey);
var xey1 = edge.Intersection(ey + 1);
var x0 = Math.Min(xey, xey1);
var x1 = Math.Max(xey, xey1);
var width = x1 - x0;
// Compute the average color of all subpixel layers before
// and after the edge intersection.
var fromColorAverage = new AverageColor();
var toColorAverage = new AverageColor();
for (var sy = 0; sy < usedLayers; sy++)
{
var subScanlineLayers = layers[sy];
fromColorAverage.Add(subScanlineLayers.CurrentColor);
toColorAverage.Add(subScanlineLayers.Add(edge));
}
var fromColor = fromColorAverage.Color;
color = toColorAverage.Color;
// Render pixels
for (var x = superSampleRange.FromX; x < superSampleRange.ToXExcl; x++)
{
if (x0 >= x + 1)
{
// Pixel not covered
writer.Write(fromColor);
continue;
}
if (x1 <= x)
{
// Pixel fully covered
writer.Write(color);
continue;
}
// toColor coverage in the range [0.0, 1.0]
// Initialize to the fully covered range of the pixel.
var coverage = x1 < x + 1 ? x + 1 - x1 : 0;
// Compute integral for non-vertical edges
if (width > 0.001f)
{
// Range to integrate
var integralFrom = Math.Max(x0, x);
var integralTo = Math.Min(x1, x + 1);
coverage +=
(
(integralTo * integralTo - integralFrom * integralFrom) / 2 +
x0 * (integralFrom - integralTo)
) / width;
}
writer.Write(Color.Mix(fromColor, color, coverage));
}
} // /simplified antialiasing
else
{
// There are more than a single intersecting edge in this range.
// Use super sampling to render the pixels.
intersections.Initialize(ranges.Count);
var y = ey + SuperSampling.SampleHeight / 2;
// Ensure all subpixel layers are initialized
while (usedLayers < SuperSampling.SamplesPerPixelY)
{
layers[0].CopyTo(layers[usedLayers]);
usedLayers++;
}
// Average color of the pixels following the current supersample range.
var forwardColorAverage = new AverageColor();
for (var sy = 0; sy < SuperSampling.SamplesPerPixelY; sy++, y += SuperSampling.SampleHeight)
{
var subScanlineLayers = layers[sy];
color = subScanlineLayers.CurrentColor;
superSampleRange.GetIntersections(ref intersections, y);
for (var i = 0; i < intersections.Count; i++)
{
ref var intersection = ref intersections[i];
superSampleBuffer.Add(color, intersection.X - superSampleRange.FromX);
color = subScanlineLayers.Add(intersection.Edge);
}
// Write an extra pixel that will contain the color that
// will be forwarded until the next supersample range.
superSampleBuffer.Add(color, superSampleRange.Width);
superSampleBuffer.Rewind();
forwardColorAverage.Add(color);
} // /subpixel
// Get color to be forwarded
color = forwardColorAverage.Color;
// Blend subpixels
superSampleBuffer.WriteTo(ref writer, superSampleRange.Width);
superSampleBuffer.Clear();
} // /supersampling
// Forward last color
if (rangeIndex + 1 < superSampleRanges.Count)
{
var nextRangeX = superSampleRanges[rangeIndex + 1].FromX;
writer.Write(color, nextRangeX - superSampleRange.ToXExcl);
}
else
{
writer.Write(color, width - superSampleRange.ToXExcl);
}
} // /range
