/// <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); }