private ColorMap GetTransitionMap(int[] sampleHist, int[] referenceHist, int n, YUVPlanes plane)
{
var map = new ColorMap(sampleBits, n, Dither);
var highRefColor = GetHighColor(referenceBits, plane);
for (int newColor = GetLowColor(referenceBits), oldColor = -1, lastOldColor = -1, lastNewColor = GetLowColor(referenceBits) - 1, restPixels = 0; newColor <= highRefColor; newColor++)
{
void MissedColors(double newColorLimit, double oldColorLimit)
{
var step = (newColorLimit - lastNewColor - 1) / (oldColorLimit - lastOldColor);
for (var tempColor = lastOldColor + 1; tempColor < oldColorLimit; tempColor++)
{
var actualColor = lastNewColor + step * (tempColor - lastOldColor);
var intergerColor = Math.Truncate(actualColor);
var val = 1 - (actualColor - intergerColor);
if (tempColor == highRefColor)
{
val = 1;
}
map.Add(tempColor, (int)intergerColor, val);
if (val <= 1 - double.Epsilon)
{
map.Add(tempColor, (int)intergerColor + 1, 1 - val);
}
}
}
var refCount = referenceHist[newColor];
var notEmpty = refCount > 0;
while (refCount > 0)
{
var add = Math.Min(restPixels, refCount);
if (add > 0)
{
map.Add(oldColor, newColor, add / (double)sampleHist[oldColor]);
refCount -= add;
restPixels -= add;
lastOldColor = oldColor;
}
else
{
restPixels = sampleHist[++oldColor];
if (restPixels != 0 && oldColor - lastOldColor > 1)
{
MissedColors(newColor, oldColor);
}
}
}
if (notEmpty)
{
lastNewColor = newColor;
}
if (newColor == highRefColor)
{
MissedColors(highRefColor + 1, 1 << sampleBits);
}
}
return(map);
}
private void Interpolate(ColorMap map, int min, int max, int srcBits, int refBits)
{
var interpolator = GetInterpolator(map);
if (interpolator == null)
{
return;
}
var firstOldColor = map.First();
var lastOldColor = map.Last();
var mult = Math.Pow(2, refBits - srcBits);
for (var oldColor = 0; oldColor < map.FixedMap.Length; oldColor++)
{
if (oldColor < firstOldColor || oldColor > lastOldColor)
{
map.Add(oldColor, oldColor * mult);
}
else if (!map.Contains(oldColor))
{
var interpolated = interpolator.Interpolate(oldColor);
interpolated = Math.Min(max, Math.Max(min, interpolated));
map.Add(oldColor, interpolated);
}
}
}
private void Extrapolate(ColorMap map, int[] srcHist, int minColor, int maxColor)
{
var min = srcHist.TakeWhile(p => p == 0).Count();
var max = srcHist.Length - srcHist.Reverse().TakeWhile(p => p == 0).Count() - 1;
var first = map.First();
var last = map.Last();
var sampleCount = last - first + 1;
var mappedColors = Enumerable.Range(first, sampleCount).Where(map.Contains);
var mappedCount = mappedColors.Count();
var limit = Math.Max(mappedCount / 10, Math.Min(mappedCount, 10));
if (min < first)
{
var avgDiff = mappedColors.Take(limit).Sum(p => map.Average(p) - p) / limit;
var mapped = min + avgDiff;
map.Add(min, Math.Max(minColor, mapped));
Log(() => $"Min: {min} -> {mapped:F3}");
}
if (max > last)
{
var avgDiff = mappedColors.Reverse().Take(limit).Sum(p => map.Average(p) - p) / limit;
var mapped = max + avgDiff;
map.Add(max, Math.Min(maxColor, mapped));
Log(() => $"Max: {max} -> {mapped:F3}");
}
}
private ColorMap GetTransitionMap(int[] sampleHist, int[] referenceHist, int n, YUVPlanes plane)
{
var map = new ColorMap(sampleBits, n, Intensity < 1 ? 1 : Dither);
var highRefColor = GetHighColor(referenceBits, plane);
for (int newColor = GetLowColor(referenceBits), oldColor = -1, restPixels = 0; newColor <= highRefColor; newColor++)
{
var refCount = referenceHist[newColor];
//var excludeReference = (double) refCount / int.MaxValue < Exclude;
while (refCount > 0)
{
var add = Math.Min(restPixels, refCount);
if (add > 0)
{
var exclude = (((double)add) / int.MaxValue) < Exclude;
if (!exclude)
{
var weight = add / (double)sampleHist[oldColor];
map.Add(oldColor, newColor, weight);
}
refCount -= add;
restPixels -= add;
}
else
{
restPixels = sampleHist[++oldColor];
}
}
}
return(map);
}
public void TestColorMap()
{
var map = new ColorMap(8, 0, 1);
map.Add(2, 3.2);
var tuples = map.GetColorsAndWeights();
Assert.AreEqual(tuples.Item1[2][0], 3);
Assert.AreEqual(tuples.Item1[2][1], 4);
Assert.AreEqual(tuples.Item2[2][0], 0.8, 0.0001);
Assert.AreEqual(tuples.Item2[2][1], 0.2, 0.0001);
}
public override void HandleInput(PointF relativeMousePos)
{
var hit = _mouseRegions.ItemUnderMouse(relativeMousePos);
var leftMousePressed = InputState.MouseButtonPressed(MouseButton.Left);
if (hit != null && hit.Item2 == ColorMap && leftMousePressed)
{
var key = KeyValueAtPos(hit.Item1, relativeMousePos);
var color = ColorMap[key];
ColorMap.Add(key, color);
Changed(ColorMap);
_selected = key;
ItemSelected(ColorMap.IndexOfKey(key));
}
else if (hit != null && hit.Item2 is float)
{
var hitKey = (float)hit.Item2;
if (leftMousePressed)
{
if (hitKey != _selected)
{
_selected = hitKey;
ItemSelected(ColorMap.IndexOfKey(hitKey));
}
_dragging = hitKey;
return;
}
else if (ColorMap.Count > 1 && InputState.MouseButtonPressed(MouseButton.Right))
{
_selected = null;
ItemSelected(null);
ColorMap.Remove(hitKey);
Changed(ColorMap);
}
}
if (_dragging != null && InputState.MouseButtonDown(MouseButton.Left))
{
var newKey = KeyValueAtPos(_mouseRegions[0].Item1, relativeMousePos);
if (newKey >= DomainMin && newKey <= DomainMax &&
ColorMap.MoveKey(_dragging.Value, newKey))
{
Changed(ColorMap);
_dragging = newKey;
_selected = newKey;
}
}
else
{
_dragging = null;
}
}
public static ColorMap BuildColorMap(this Bitmap source)
{
var map = new ColorMap();
source.GetPixels().Select(p =>
{
if (map.ContainsKey(p.Color)) {
map[p.Color]++;
} else {
map.Add(p.Color, 1);
}
return p;
}).ToList();
return map;
}
private static ConsoleColor GetEventsColor(Guid id)
{
if (ColorMap.TryGetValue(id, out var color))
{
return(color);
}
color = PetitionColors[CurrentColor];
ColorMap.Add(id, color);
if (CurrentColor == PetitionColors.Length - 1)
{
CurrentColor = 0;
}
else
{
CurrentColor++;
}
return(color);
}
protected override VideoFrame GetFrame(int n)
{
var input = Child.GetFrame(n, StaticEnv);
if (Intensity <= double.Epsilon)
{
return(input);
}
var sampleFrames = Enumerable.Range(n - tr, tr * 2 + 1).Select(p => Sample.GetFrame(p, StaticEnv)).ToList();
var referenceFrames = Enumerable.Range(n - tr, tr * 2 + 1).Select(p => Reference.GetFrame(p, StaticEnv)).ToList();
var inputFrames = tr == 0
? new List <VideoFrame> {
input
}
: Enumerable.Range(n - tr, tr * 2 + 1).Select(p => Child.GetFrame(p, StaticEnv)).ToList();
var writable = GetVideoInfo().pixel_type == Child.GetVideoInfo().pixel_type&& StaticEnv.MakeWritable(input);
var output = writable ? input : NewVideoFrame(StaticEnv);
using (var sampleMaskFrame = SampleMask?.GetFrame(n, StaticEnv))
using (var refMaskFrame = ReferenceMask?.GetFrame(n, StaticEnv))
{
var pixelSize = Sample.GetVideoInfo().IsRGB() ? 3 : 1;
Parallel.ForEach(planes, plane =>
{
Parallel.ForEach(realChannels, channel =>
{
int[] sampleHist = null, referenceHist = null, srcHist = null;
Parallel.Invoke(
() => sampleHist = GetHistogram(sampleFrames, sampleMaskFrame, pixelSize, channel, plane, Sample.GetVideoInfo().pixel_type, sampleBits, false),
() => referenceHist = GetHistogram(referenceFrames, refMaskFrame, pixelSize, channel, plane, Reference.GetVideoInfo().pixel_type, referenceBits, LimitedRange),
() => srcHist = Extrapolation ? GetHistogram(inputFrames, null, pixelSize, channel, plane, Child.GetVideoInfo().pixel_type, sampleBits, LimitedRange) : null);
var map = GetTransitionMap(sampleHist, referenceHist, n, plane);
if (Extrapolation)
{
Extrapolate(map, srcHist, GetLowColor(referenceBits), GetHighColor(referenceBits, plane));
}
Interpolate(map, GetLowColor(referenceBits), GetHighColor(referenceBits, plane), sampleBits, referenceBits);
if (Intensity < 1)
{
var decreased = new ColorMap(sampleBits, n, Dither);
for (var color = 0; color < 1 << sampleBits; color++)
{
decreased.Add(color, map.Average(color) * Intensity + color * (1 - Intensity));
}
map = decreased;
}
var tuple = map.GetColorsAndWeights();
NativeUtils.ApplyColorMap(DynamicNoise ? n : 0,
input.GetReadPtr(plane), input.GetPitch(plane), sampleBits > 8,
output.GetWritePtr(plane), output.GetPitch(plane), referenceBits > 8,
input.GetRowSize(plane), input.GetHeight(plane), pixelSize, channel,
map.FixedMap, tuple.Item1, tuple.Item2);
});
});
}
if (!writable)
{
input.Dispose();
}
sampleFrames.ForEach(p => p.Dispose());
referenceFrames.ForEach(p => p.Dispose());
return(output);
}