/// <summary>
/// Initializes quantization tables.
/// </summary>
/// <remarks>
/// We take quality values in a hierarchical order:
/// 1. Check if encoder has set quality
/// 2. Check if metadata has special table for encoding
/// 3. Check if metadata has set quality
/// 4. Take default quality value - 75
/// </remarks>
/// <param name="componentCount">Color components count.</param>
/// <param name="metadata">Jpeg metadata instance.</param>
/// <param name="luminanceQuantTable">Output luminance quantization table.</param>
/// <param name="chrominanceQuantTable">Output chrominance quantization table.</param>
private void InitQuantizationTables(int componentCount, JpegMetadata metadata, out Block8x8F luminanceQuantTable, out Block8x8F chrominanceQuantTable)
{
int lumaQuality;
int chromaQuality;
if (this.quality.HasValue)
{
lumaQuality = this.quality.Value;
chromaQuality = this.quality.Value;
}
else
{
lumaQuality = metadata.LuminanceQuality;
chromaQuality = metadata.ChrominanceQuality;
}
// Luminance
lumaQuality = Numerics.Clamp(lumaQuality, 1, 100);
luminanceQuantTable = Quantization.ScaleLuminanceTable(lumaQuality);
// Chrominance
chrominanceQuantTable = default;
if (componentCount > 1)
{
chromaQuality = Numerics.Clamp(chromaQuality, 1, 100);
chrominanceQuantTable = Quantization.ScaleChrominanceTable(chromaQuality);
if (!this.colorType.HasValue)
{
this.colorType = chromaQuality >= 91 ? JpegColorType.YCbCrRatio444 : JpegColorType.YCbCrRatio420;
}
}
}
public static BitmapSource QuantizeInRgb(BitmapSource bitmap, object parameter)
{
var quantizationVector = parameter as Vector <byte>;
var colors = bitmap.GetColors().Select(c => Quantization.QuantizeVector(c, quantizationVector)).ToArray();
return(bitmap.Create(colors));
}
public override Schematic WriteSchematic()
{
float minX = _blocks.MinBy(t => t.X).X;
float minY = _blocks.MinBy(t => t.Y).Y;
float minZ = _blocks.MinBy(t => t.Z).Z;
float maxX = _blocks.MaxBy(t => t.X).X;
float maxY = _blocks.MaxBy(t => t.Y).Y;
float maxZ = _blocks.MaxBy(t => t.Z).Z;
Schematic schematic = new Schematic()
{
Length = (ushort)(Math.Abs(maxZ - minZ)),
Width = (ushort)(Math.Abs(maxX - minX)),
Heigth = (ushort)(Math.Abs(maxY - minY)),
Blocks = new HashSet <Block>()
};
LoadedSchematic.LengthSchematic = schematic.Length;
LoadedSchematic.WidthSchematic = schematic.Width;
LoadedSchematic.HeightSchematic = schematic.Heigth;
List <Block> list = Quantization.ApplyQuantization(_blocks);
list.ApplyOffset(new Vector3(minX, minY, minZ));
HashSet <Block> hashSet = list.ToHashSet();
//RemoveHoles(ref hashSet, schematic);
schematic.Blocks = hashSet;
return(schematic);
}
public override Schematic WriteSchematic()
{
float minX = _blocks.MinBy(t => t.X).X;
float minY = _blocks.MinBy(t => t.Y).Y;
float minZ = _blocks.MinBy(t => t.Z).Z;
Schematic schematic = new Schematic();
List <Voxel> list = Quantization.ApplyQuantization(_blocks, _colorLimit);
list.ApplyOffset(new Vector3(minX, minY, minZ));
HashSet <Voxel> hashSet = list.ToHashSet();
if (_holes)
{
hashSet = FillHoles(hashSet.To3DArray(schematic), schematic);
}
if (_flood)
{
hashSet = FillInvisiblesVoxels(hashSet.To3DArray(schematic), schematic);
}
if (_lonely)
{
hashSet = FixLonelyVoxels(hashSet.To3DArray(schematic), schematic);
}
schematic.Blocks = hashSet;
return(schematic);
}
public override Schematic WriteSchematic()
{
List <Voxel> list = Quantization.ApplyQuantization(mSchematic.GetAllVoxels(), ColorLimit);
Schematic schematic = new Schematic(list);
return(schematic);
}
private static Output GetOutput(ConfigFile config)
{
string text = config.OutputFile.ToLower();
string a = Path.GetExtension(text).ToLowerInvariant();
if (a == ".bin")
{
return(new LabSat1Output(config.OutputFile));
}
Quantization bitsPerSample = (Quantization)config.BitsPerSample;
if (a == ".ls3w")
{
return(new LabSat3wOutput(config.OutputFile, config.SignalTypes, bitsPerSample));
}
if (a == ".ls2")
{
return(new LabSat2Output(config.OutputFile, config.SignalTypes, bitsPerSample));
}
if (text == "%labsat2%")
{
return(new LabSat2LiveOutput(config.SignalTypes, bitsPerSample, isLowLatency: true));
}
if (text == "%labsat2rt%")
{
DateTime utcNow = DateTime.UtcNow;
GnssTime value = GnssTime.FromUtc(new DateTime(utcNow.Ticks - utcNow.Ticks % 10000000) + TimeSpan.FromSeconds(10.0));
return(new LabSat2LiveOutput(config.SignalTypes, bitsPerSample, isLowLatency: true, value));
}
if (a == ".ls3")
{
return(new LabSat3Output(config.OutputFile, config.SignalTypes, bitsPerSample));
}
throw new ArgumentException("No supported output type for file \"" + config.OutputFile + "\"");
}
public override Schematic WriteSchematic()
{
int height = mImages.Count;
Console.WriteLine("[INFO] Total images to process: " + mImages.Count);
List <Voxel> blocks = new List <Voxel>();
Bitmap bitmapColor = null;
if (mInputColorFile != null)
{
bitmapColor = new Bitmap(mInputColorFile);
if (bitmapColor.Width > 256 || bitmapColor.Height > 1)
{
throw new ArgumentException("[ERROR] The input color file must have a dimension of 256x1 px");
}
}
for (int i = 0; i < mImages.Count; i++)
{
string file = mImages[i];
Console.WriteLine("[INFO] Reading file: " + file);
Bitmap bitmap = new Bitmap(file);
DirectBitmap directBitmap = new DirectBitmap(bitmap, 1);
for (int x = 0; x < directBitmap.Width; x++)
{
for (int y = 0; y < directBitmap.Length; y++)
{
Color color = directBitmap.GetPixel(x, y);
if (color != Color.Empty && color != Color.Transparent && color != Color.Black && (color.R != 0 && color.G != 0 && color.B != 0))
{
if (mInputColorFile != null)
{
double distance = Math.Sqrt(Math.Pow((height / 2) - x, 2) + Math.Pow((height / 2) - y, 2));
float range = (float)Math.Abs(distance / (height / 2)); //
range = range > 1 ? 1 : range;
color = bitmapColor.GetPixel((int)(range * (bitmapColor.Width - 1)), 0);
}
if (mExcavate)
{
CheckNeighbor(ref blocks, directBitmap, color, i, x, y);
}
else
{
blocks.Add(new Voxel((ushort)x, (ushort)i, (ushort)y, color.ColorToUInt()));
}
}
}
}
directBitmap.Dispose();
}
List <Voxel> list = Quantization.ApplyQuantization(blocks, mColorLimit);
Schematic schematic = new Schematic(list);
Console.WriteLine("[INFO] Done.");
return(schematic);
}
public static BitmapSource QuantizeInYCbCr(BitmapSource bitmap, object parameter)
{
var quantizationVector = parameter as Vector <byte>;
var colors = Transformation.YCbCrToRGB(
Transformation.RGBToYCbCr(bitmap.GetColors())
.Select(c => Quantization.QuantizeVector(c, quantizationVector)).ToArray()
);
return(bitmap.Create(colors));
}
private static HashSet <Vector <byte> > CreateQuantizedSet(Vector <byte>[] colors, byte i)
{
var quantizationVector = QuantizationVectorFunc(i);
var result = new HashSet <Vector <byte> >();
foreach (var color in colors)
{
result.Add(Quantization.QuantizeVector(color, quantizationVector));
}
return(result);
}
public void Quant()
{
if (SelectedSampledSignal != null && SelectedSampledSignal.HasData())
{
var sampledSignal = (SampledSignal)SelectedSampledSignal;
SampledSignal signal = new SampledSignal();
signal.PointsX = sampledSignal.PointsX;
signal.StartTime = sampledSignal.StartTime;
signal.Frequency = sampledSignal.Frequency;
signal.PointsY = Quantization.Quantize(sampledSignal.PointsY, QuantCount);
signal.Name = QuantSignalName + " - Q";
SignalCreator.AddSignal(signal);
}
}
public static Image2 Quantize(this Image2 source, Quantization mode = Quantization.Octree, int maxColors = 256)
{
IQuantizer quantizer;
switch (mode){
case Quantization.Wu:
quantizer = new WuQuantizer();
break;
case Quantization.Palette:
quantizer = new PaletteQuantizer();
break;
default:
quantizer = new OctreeQuantizer();
break;
}
return Quantize(source, quantizer, maxColors);
}
public override Schematic WriteSchematic()
{
float minX = _blocks.MinBy(t => t.X).X;
float minY = _blocks.MinBy(t => t.Y).Y;
float minZ = _blocks.MinBy(t => t.Z).Z;
float maxX = _blocks.MaxBy(t => t.X).X;
float maxY = _blocks.MaxBy(t => t.Y).Y;
float maxZ = _blocks.MaxBy(t => t.Z).Z;
Schematic schematic = new Schematic()
{
Length = (ushort)(Math.Abs(maxZ - minZ) + 1),
Width = (ushort)(Math.Abs(maxX - minX) + 1),
Height = (ushort)(Math.Abs(maxY - minY) + 1),
Blocks = new HashSet <Block>()
};
LoadedSchematic.LengthSchematic = schematic.Length;
LoadedSchematic.WidthSchematic = schematic.Width;
LoadedSchematic.HeightSchematic = schematic.Height;
List <Block> list = Quantization.ApplyQuantization(_blocks, _colorLimit);
list.ApplyOffset(new Vector3(minX, minY, minZ));
HashSet <Block> hashSet = list.ToHashSet();
if (_holes)
{
hashSet = FillHoles(hashSet.To3DArray(schematic), schematic);
}
if (_flood)
{
hashSet = FillInvisiblesVoxels(hashSet.To3DArray(schematic), schematic);
}
if (_lonely)
{
hashSet = FixLonelyVoxels(hashSet.To3DArray(schematic), schematic);
}
schematic.Blocks = hashSet;
return(schematic);
}
public static void TestQuantization()
{
var input = PictureHelper.GenerateRandomChannel(32, 32);
var output = Transformation.TransformArai(input);
Console.WriteLine(output.ToString(32, 32));
var result = Quantization.Quantisize(output, QTType.CHROMINANCE);
var rowLength = result.GetLength(0);
var columnLength = result.GetLength(1);
for (int i = 0; i < rowLength; i++)
{
for (int j = 0; j < columnLength; j++)
{
Console.Write(result[i, j] + ", ");
}
Console.WriteLine();
}
}
public static Image2 Quantize(this Image2 source, Quantization mode = Quantization.Octree, int maxColors = 256)
{
IQuantizer quantizer;
switch (mode)
{
case Quantization.Wu:
quantizer = new WuQuantizer();
break;
case Quantization.Palette:
quantizer = new PaletteQuantizer();
break;
default:
quantizer = new OctreeQuantizer();
break;
}
return(Quantize(source, quantizer, maxColors));
}
public static void TestDecToBin()
{
WriteBinaryRepresentations(0, 3);
WriteBinaryRepresentations(1, 3);
WriteBinaryRepresentations(2, 3);
WriteBinaryRepresentations(3, 3);
WriteBinaryRepresentations(4, 3);
WriteBinaryRepresentations(5, 3);
WriteBinaryRepresentations(6, 3);
WriteBinaryRepresentations(7, 3);
Console.WriteLine();
Quantization quantization = new Quantization(3);
quantization.PrintRanges();
Console.WriteLine("\n double to int:");
Console.WriteLine("0.55 -> " + quantization.NormalizedDoubleToInteger(0.55));
Console.WriteLine("0.11 -> " + quantization.NormalizedDoubleToInteger(0.11));
Console.WriteLine("0.95 -> " + quantization.NormalizedDoubleToInteger(0.95));
Console.WriteLine("0.63 -> " + quantization.NormalizedDoubleToInteger(0.63));
}
/// <summary>
/// Applies quantization to the image.
/// </summary>
/// <typeparam name="TColor">The pixel format.</typeparam>
/// <param name="source">The image this method extends.</param>
/// <param name="mode">The quantization mode to apply to perform the operation.</param>
/// <param name="maxColors">The maximum number of colors to return. Defaults to 256.</param>
/// <returns>The <see cref="Image{TColor}"/>.</returns>
public static Image <TColor> Quantize <TColor>(this Image <TColor> source, Quantization mode = Quantization.Octree, int maxColors = 256)
where TColor : struct, IPackedPixel, IEquatable <TColor>
{
IQuantizer <TColor> quantizer;
switch (mode)
{
case Quantization.Wu:
quantizer = new WuQuantizer <TColor>();
break;
case Quantization.Palette:
quantizer = new PaletteQuantizer <TColor>();
break;
default:
quantizer = new OctreeQuantizer <TColor>();
break;
}
return(Quantize(source, quantizer, maxColors));
}
private Maybe <Bitmap> LoadMinimapFromUser()
{
var loc = this.dialogService.AskUserToChooseMinimap();
if (loc == null)
{
return(Maybe.None <Bitmap>());
}
try
{
Bitmap bmp;
using (var s = File.OpenRead(loc))
{
bmp = (Bitmap)Image.FromStream(s);
}
if (bmp.Width > TntConstants.MaxMinimapWidth ||
bmp.Height > TntConstants.MaxMinimapHeight)
{
var msg = string.Format(
"Minimap dimensions too large. The maximum size is {0}x{1}.",
TntConstants.MaxMinimapWidth,
TntConstants.MaxMinimapHeight);
this.dialogService.ShowError(msg);
return(Maybe.None <Bitmap>());
}
Quantization.ToTAPalette(bmp);
return(Maybe.Some(bmp));
}
catch (Exception)
{
this.dialogService.ShowError("There was a problem importing the selected minimap.");
return(Maybe.None <Bitmap>());
}
}
/// <summary>
/// Applies quantization to the image.
/// </summary>
/// <typeparam name="T">The pixel format.</typeparam>
/// <typeparam name="TP">The packed format. <example>long, float.</example></typeparam>
/// <param name="source">The image this method extends.</param>
/// <param name="mode">The quantization mode to apply to perform the operation.</param>
/// <param name="maxColors">The maximum number of colors to return. Defaults to 256.</param>
/// <returns>The <see cref="Image{T,TP}"/>.</returns>
public static Image <T, TP> Quantize <T, TP>(this Image <T, TP> source, Quantization mode = Quantization.Octree, int maxColors = 256)
where T : IPackedVector <TP>
where TP : struct
{
IQuantizer <T, TP> quantizer;
switch (mode)
{
case Quantization.Wu:
quantizer = new WuQuantizer <T, TP>();
break;
case Quantization.Palette:
quantizer = new PaletteQuantizer <T, TP>();
break;
default:
quantizer = new OctreeQuantizer <T, TP>();
break;
}
return(Quantize(source, quantizer, maxColors));
}
public float GetProgressToNextQuantum(Quantization q)
{
switch (q)
{
case Quantization.kMeasure:
return (elapsedBeats / beatsPerMeasure) % 1.0f;
case Quantization.kHalf:
return (2.0f * elapsedBeats / beatsPerMeasure) % 1.0f;
case Quantization.kBeat:
return elapsedBeats%1.0f;
case Quantization.kEighth:
return (elapsedBeats*2.0f)%1.0f;
case Quantization.kSixteenth:
return (elapsedBeats*4.0f)%1.0f;
default:
Debug.Log ("Unknown quantization");
return 0.0f;
}
}
/// <summary>
/// Applies quantization to the image.
/// </summary>
/// <typeparam name="TPixel">The pixel format.</typeparam>
/// <param name="source">The image this method extends.</param>
/// <param name="mode">The quantization mode to apply to perform the operation.</param>
/// <param name="maxColors">The maximum number of colors to return. Defaults to 256.</param>
/// <returns>The <see cref="Image{TPixel}"/>.</returns>
public static IImageProcessingContext <TPixel> Quantize <TPixel>(this IImageProcessingContext <TPixel> source, Quantization mode = Quantization.Octree, int maxColors = 256)
where TPixel : struct, IPixel <TPixel>
{
IQuantizer <TPixel> quantizer;
switch (mode)
{
case Quantization.Wu:
quantizer = new WuQuantizer <TPixel>();
break;
case Quantization.Palette:
quantizer = new PaletteQuantizer <TPixel>();
break;
default:
quantizer = new OctreeQuantizer <TPixel>();
break;
}
return(Quantize(source, quantizer, maxColors));
}
public static void SetQuantization(Quantization mode) {
ilSetInteger((uint) ILDefines.IL_QUANTIZATION_MODE, (int) mode);
}
public static void runoutside(string[] args)
{
Console.WriteLine("blah.exe profile.txt");
string[] commandLineArgs = Environment.GetCommandLineArgs();
ConfigFile config = ConfigFile.Read(commandLineArgs[1]);
Console.WriteLine(config.ToJSON());
//Environment.NewLine = "\r\n";
using (NmeaFile nmeaFile = new NmeaFile(config.NmeaFile))
{
//Console.WriteLine(nmeaFile.ToJSON());
}
string text = config.OutputFile.ToLower();
string a = Path.GetExtension(text) !.ToLowerInvariant();
Quantization bitsPerSample = (Quantization)config.BitsPerSample;
var output = new LabSat3wOutput(config.OutputFile, config.SignalTypes, bitsPerSample);
Console.WriteLine(output.ChannelPlan.ToJSON());
GnssTime startTime = GnssTime.FromUtc(config.Date);
Console.WriteLine(startTime.ToJSON());
Trajectory trajectory = new NmeaFileTrajectory(in startTime, config.NmeaFile, config.GravitationalModel);
Range <GnssTime, GnssTimeSpan> interval = trajectory.Interval;
Console.WriteLine(interval.ToJSON());
IReadOnlyList <ConstellationBase> readOnlyList = ConstellationBase.Create(config.SignalTypes);
foreach (ConstellationBase item in readOnlyList)
{
string almanacPath = GetAlmanacPath(item.ConstellationType, config);
if (!item.LoadAlmanac(almanacPath, in startTime))
{
string text2 = "Invalid " + item.ConstellationType.ToLongName() + " almanac file \"" +
Path.GetFileName(almanacPath) + "\"";
RLLogger.GetLogger().LogMessage(text2);
//MessageBox.Show(Application.Current.MainWindow, text2, "SatGen error", MessageBoxButton.OK, MessageBoxImage.Hand);
return;
}
AlmanacBase?almanac = item.Almanac;
GnssTime simulationTime = interval.Start;
almanac !.UpdateAlmanacForTime(in simulationTime);
}
Console.WriteLine(
(config.SignalTypes, trajectory, interval, output,
/*readOnlyList*/ 0, config.Mask, config.Attenuation).ToJSON());
var simulation = Simulation.Create(new SimulationParams(config.SignalTypes, trajectory, in interval, output,
readOnlyList, config.Mask, config.Attenuation));
DoPatch();
simulation.Start();
var progress = 0.0;
simulation.ProgressChanged += (o, e) => { progress = e.Progress; };
while (simulation.SimulationState != SimulationState.Finished)
{
Thread.Sleep(1000);
Console.WriteLine("{0} {1} ", progress, simulation.SimulationState);
}
}
public override Schematic WriteSchematic()
{
int height = Directory.GetFiles(_path, "*.*", SearchOption.AllDirectories).Count(s => s.EndsWith(".png"));
Console.WriteLine("[INFO] Count files in the folder : " + height);
List <Block> blocks = new List <Block>();
Bitmap bitmapColor = null;
if (_inputColorFile != null)
{
bitmapColor = new Bitmap(_inputColorFile);
if (bitmapColor.Width > 256 || bitmapColor.Height > 1)
{
throw new ArgumentException("[ERROR] The input color file must have a dimension of 256x1 px");
}
}
int maxWidth = 0;
int maxLength = 0;
using (ProgressBar progressbar = new ProgressBar())
{
string[] files = Directory.GetFiles(_path);
for (int i = 0; i < files.Length; i++)
{
string file = files[i];
Bitmap bitmap = new Bitmap(file);
DirectBitmap directBitmap = new DirectBitmap(bitmap);
for (int x = 0; x < directBitmap.Width; x++)
{
for (int y = 0; y < directBitmap.Height; y++)
{
Color color = directBitmap.GetPixel(x, y);
if (color != Color.Empty && color != Color.Transparent && color != Color.Black && (color.R != 0 && color.G != 0 && color.B != 0))
{
if (_inputColorFile != null)
{
double distance = Math.Sqrt(Math.Pow((height / 2) - x, 2) + Math.Pow((height / 2) - y, 2));
float range = (float)Math.Abs(distance / (height / 2)); //
range = range > 1 ? 1 : range;
color = bitmapColor.GetPixel((int)(range * (bitmapColor.Width - 1)), 0);
}
maxWidth = maxWidth < directBitmap.Width ? directBitmap.Width : maxWidth;
maxLength = maxLength < directBitmap.Height ? directBitmap.Height : maxLength;
if (_excavate)
{
CheckNeighbor(ref blocks, directBitmap, color, i, x, y);
}
else
{
blocks.Add(new Block((ushort)x, (ushort)i, (ushort)y, color.ColorToUInt()));
}
}
}
}
directBitmap.Dispose();
progressbar.Report(i / (float)files.Length);
}
}
Schematic schematic = new Schematic();
schematic.Height = (ushort)height;
schematic.Width = (ushort)maxWidth;
schematic.Length = (ushort)maxLength;
LoadedSchematic.HeightSchematic = schematic.Height;
LoadedSchematic.LengthSchematic = schematic.Length;
LoadedSchematic.WidthSchematic = schematic.Width;
List <Block> list = Quantization.ApplyQuantization(blocks, _colorLimit);
schematic.Blocks = list.ToHashSet();
Console.WriteLine("[LOG] Done.");
return(schematic);
}
public static void SetQuantization(Quantization mode)
{
IL.ilSetInteger(1600U, (int)mode);
}
