public static Buffer CreateLutBuffer(float f_x, float f_y)
{
var filter =
//new MitchelFilter(f_x, f_y);
new GaussianFilter(f_x, f_y);
float[] Gaussian2x2_filterTable = new float[16 * 16];
for (var y = 0; y < 16; ++y)
{
float fy = (y + 0.5f) * 2.0f / 16.0f;
for (var x = 0; x < 16; ++x)
{
float fx = (x + 0.5f) * 2.0f / 16.0f;
Gaussian2x2_filterTable[x + y * 16] = filter.Evaluate(fx, fy);
//Max<float>(0.f, expf(-alpha * fx * fx) - expX) *Max<float>(0.f, expf(-alpha * fy * fy) - expY);
}
}
BufferDesc desc = new BufferDesc()
{
Width = 16 * 16,
Type = BufferType.Input,
Format = Format.Float
};
Buffer res = new Buffer(ComponentPipeline.Instance.Session.OptixContext, desc);
res.SetData(Gaussian2x2_filterTable);
return res;
}
public void GaussianImage()
{
Task task = Task.Factory.StartNew(() =>
{
ClearPerfomanceInfo();
RaisePropertyChanged("PerfomanceInfo");
CanNewExecute = false;
try
{
GaussianFilter filter = new GaussianFilter();
RGB[,] pixels = ImageHelper.GetPixels(OriginImage.Bitmap);
if (pixels != null)
{
filter.Filter(OriginImage.Bitmap.Width, OriginImage.Bitmap.Height, pixels, Sigma);
SegmentedImage = new ImageViewModel(ImageHelper.GetFilterBitmap(pixels));
}
}
catch { }
finally
{
CanNewExecute = true;
}
});
}
public void GivenAnImageWithUniformPixels_WhenSmoothed_ThenAllValuesAreEqual_AndUnchanged()
{
// arrange
const byte expectedPixelValue = 10;
AssignPixels(expectedPixelValue);
var imageSmoothing = new ImageSmoothing(_pixels);
var gaussianFilter = new GaussianFilter(5, 1);
// act
var smoothedPixels = imageSmoothing.SmoothImage(gaussianFilter);
// assert
var count = 0;
for (var y = 0; y < Rows; ++y)
{
for (var x = 0; x < Columns; ++x)
{
Assert.AreEqual(expectedPixelValue, smoothedPixels[x, y]);
++count;
}
}
Assert.AreEqual(Rows * Columns, count);
}
public override void In(FlowEventArgs e)
{
SetValue(nameof(Disperson));
Filter = new GaussianFilter
{
Disperson = Disperson
};
OnSuccess();
}
private void gaussianToolStripMenuItem_Click(object sender, EventArgs e)
{
if (pictureBox1.Image != null)
{
cashBack.Push(image);
}
Filters filter = new GaussianFilter();
backgroundWorker1.RunWorkerAsync(filter);
}
private void азмытиеПоГToolStripMenuItem_Click(object sender, EventArgs e)
{
var bm = new Bitmap(pictureBox1.Image);
old_image = image;
image = bm;
Filters filter = new GaussianFilter();
backgroundWorker1.RunWorkerAsync(filter);
}
public GaussianBlurConfiguration(int kernel, double sigma, GaussianFilter filterType)
{
if (filterType == GaussianFilter.None)
{
throw new ArgumentException($"Can't combine None configuration with kernel {kernel} and sigma {sigma}");
}
Kernel = kernel;
Sigma = sigma;
GaussianFilter = filterType;
}
public void GivenGaussianFilterWithDimension9_AndDeviation2_WhenCalculatingAreaUnderMask_ThenEquals1
()
{
// act
var filter = new GaussianFilter(9, 2);
// assert
var sum = filter.Filter.Sum();
var comparer = new DoubleComparer(1e-8);
Assert.AreEqual(0, comparer.Compare(1, sum));
}
public void GivenGaussianFilter_WhenCreatedWithDimension7_AndDeviation1_ThenFilterGeneratedWithinTolerance
()
{
// arrange
var expectedFilter = new[] { 0.00598, 0.060626, 0.241843, 0.383103, 0.241843, 0.060626, 0.00598 };
// act
var filter = new GaussianFilter(7, 1);
// assert
CollectionAssert.AreEqual(expectedFilter, filter.Filter, new DoubleComparer(1e-4));
}
public void GivenGaussianFilter_WhenCreatedWithDimension5_AndDeviation1_ThenFilterGeneratedWithinTolerance
()
{
// arrange
var expectedFilter = new[] { 0.06136, 0.24477, 0.38774, 0.24477, 0.06136 };
// act
var filter = new GaussianFilter(5, 1);
// assert
CollectionAssert.AreEqual(expectedFilter, filter.Filter, new DoubleComparer(1e-4));
}
public void GivenGaussianFilter_WhenCreatedWithDimension5_AndDeviation2_ThenFilterGeneratedWithinTolerance
()
{
// arrange
var expectedFilter = new[] { 0.153388, 0.221461, 0.250301, 0.221461, 0.153388 };
// act
var filter = new GaussianFilter(5, 2);
// assert
CollectionAssert.AreEqual(expectedFilter, filter.Filter, new DoubleComparer(1e-4));
}
public void GivenGaussianFilter_WhenCreatedWithDimension7_AndDeviation2_ThenFilterGeneratedWithinTolerance
()
{
// arrange
var expectedFilter = new[] { 0.071303, 0.131514, 0.189879, 0.214607, 0.189879, 0.131514, 0.071303 };
// act
var filter = new GaussianFilter(7, 2);
// assert
CollectionAssert.AreEqual(expectedFilter, filter.Filter, new DoubleComparer(1e-4));
}
public static Reaction <Camera> Renderer(SceneGraph scene,
int mapSize, ShadowMapType type, bool cascaded)
{
var depthFramebuffer = new Framebuffer(FramebufferTarget.Framebuffer);
_shadowShader = cascaded ?
new GLProgram(
VertexShaderCascaded(),
GeometryShaderCascaded(),
DepthFragmentShader()) :
new GLProgram(
VertexShader(),
type == ShadowMapType.Depth ? DepthFragmentShader() : VarianceFragmentShader());
_instance = new Shadows(_shadowShader, cascaded);
Texture depthTexture;
var render = React.By <Camera> (_instance.Render);
if (type == ShadowMapType.Depth || cascaded)
{
depthTexture = cascaded ?
new Texture(TextureTarget.Texture2DArray, PixelInternalFormat.DepthComponent16,
mapSize, mapSize, CascadedShadowUniforms.MapCount, PixelFormat.DepthComponent,
PixelType.Float, IntPtr.Zero) :
new Texture(TextureTarget.Texture2D, PixelInternalFormat.DepthComponent16,
mapSize, mapSize, PixelFormat.DepthComponent, PixelType.Float, IntPtr.Zero);
depthFramebuffer.AddTexture(FramebufferAttachment.DepthAttachment, depthTexture);
}
else
{
depthTexture = new Texture(TextureTarget.Texture2D, PixelInternalFormat.Rg32f,
mapSize, mapSize, PixelFormat.Rg, PixelType.Float, IntPtr.Zero);
depthFramebuffer.AddTexture(FramebufferAttachment.ColorAttachment0, depthTexture);
depthFramebuffer.AddRenderbuffer(FramebufferAttachment.DepthAttachment,
RenderbufferStorage.DepthComponent16, mapSize, mapSize);
var gaussTexture = new Texture(TextureTarget.Texture2D, PixelInternalFormat.Rg32f,
mapSize / 2, mapSize / 2, PixelFormat.Rg, PixelType.Float, IntPtr.Zero);
render = render.And(GaussianFilter.Both().MapInput((Camera cam) =>
Tuple.Create(depthTexture, gaussTexture)));
}
scene.GlobalLighting.ShadowMap = depthTexture;
return(render
.DrawBuffer(type == ShadowMapType.Depth ? DrawBufferMode.None : DrawBufferMode.Front)
.DepthTest()
.Culling()
.Viewport(new Vec2i(mapSize, mapSize))
.Program(_shadowShader)
.Texture(depthTexture)
.Framebuffer(depthFramebuffer));
}
private void btn_Wiener_Click(object sender, EventArgs e)
{
var sw = new Stopwatch();
var initialImage = (Bitmap)pictureBox1.Image;
var greyImage = ImageHelper.ToGray(initialImage);
pictureBox1.Image = greyImage;
var brokenImage = new Bitmap(greyImage);
switch (Filter)
{
case ImageHelper.Filter.Gauss:
brokenImage = GaussianFilter.Blur(greyImage, kernelSize);
break;
case ImageHelper.Filter.Sharpen:
brokenImage = SharpenFilter.Sharpen(greyImage, kernelSize);
break;
case ImageHelper.Filter.MotionLeftToRight:
brokenImage = MotionFilter.Motion(greyImage, kernelSize, Direction.LeftToRight);
break;
case ImageHelper.Filter.MotionRightToLeft:
brokenImage = MotionFilter.Motion(greyImage, kernelSize, Direction.RightToLeft);
break;
default:
break;
}
pictureBox2.Image = brokenImage;
var coreImage = ImageHelper.GetCoreImage(ImageHelper.ToGray(brokenImage), Filter);
pictureBox3.Image = coreImage;
sw.Start();
var reconstructedImage = WienerFilter.Filter(ImageHelper.ToGray(brokenImage), Filter);
pictureBox4.Image = reconstructedImage;
sw.Stop();
MessageBox.Show($"{ImageHelper.GetPSNR(greyImage, reconstructedImage)}");
//MessageBox.Show(sw.Elapsed.TotalSeconds.ToString());
}
private void btn_Gaussian_Click(object sender, EventArgs e)
{
var sw = new Stopwatch();
sw.Start();
var initialImage = (Bitmap)Image.FromFile(openFileDialog1.FileName);
var brokenImage = GaussianFilter.Blur(initialImage, kernelSize);
pictureBox2.Image = brokenImage;
sw.Stop();
Filter = ImageHelper.Filter.Gauss;
//MessageBox.Show(sw.Elapsed.TotalSeconds.ToString());
}
public void SegmentImage()
{
Task task = Task.Factory.StartNew(() =>
{
CanNewExecute = false;
try
{
IFhSegmentation segmentation = SegmentationFactory.Instance.GetFhSegmentation(SortModification, MargeHeuristic);
RGB[,] pixels = ImageHelper.GetPixels(OriginImage.Bitmap);
if (pixels != null)
{
var input = OriginImage.Bitmap;
int[] klabels;
int numlabels;
var watch = Stopwatch.StartNew();
var superPixel = new SLICO().PerformSLICO_ForGivenK(
ref input,
out klabels,
out numlabels,
N,
Color.Red);
watch.Stop();
perfomanceInfo.SuperpixelPerfomance = watch.ElapsedMilliseconds;
BitmapData bitmapData = superPixel.LockBits(new Rectangle(0, 0, superPixel.Width, superPixel.Height), ImageLockMode.ReadOnly, superPixel.PixelFormat);
var superpixels = ImageHelper.ToMatrix(klabels, bitmapData.Width, bitmapData.Height,
bitmapData.Stride);
GaussianFilter filter = new GaussianFilter();
filter.Filter(OriginImage.Bitmap.Width, OriginImage.Bitmap.Height, pixels, Sigma);
int[,] segments = segmentation.BuildSegments(OriginImage.Bitmap.Width, OriginImage.Bitmap.Height, pixels, K, MinSize, Connection, DifType, ref perfomanceInfo, superpixels);
if (RandomColor)
{
SegmentedImage = new ImageViewModel(ImageHelper.GetBitmap(segments));
}
else
{
SegmentedImage = new ImageViewModel(ImageHelper.GetBitmap(segments, pixels, MakeBorders));
}
RaisePropertyChanged("PerfomanceInfo");
}
}
catch { }
finally
{
CanNewExecute = true;
}
});
}
public FilterGenerator(int quadrantSize, LocalTerrain localTerrain)
{
globalFilterMountainC = new GlobalCoordinates(100);
globalFilterAverageC = new GlobalCoordinates(100);
globalFilterMedianC = new GlobalCoordinates(100);
globalFilterSpikeC = new GlobalCoordinates(100);
globalFilterGaussianC = new GlobalCoordinates(100);
globalFilterMinThresholdC = new GlobalCoordinates(100);
globalFilterMaxThresholdC = new GlobalCoordinates(100);
lt = localTerrain;
localCoordinates = lt.localTerrainC;
mf = new MountainFilter(this);
af = new AverageFilter(this);
mdf = new MedianFilter(this);
sf = new SpikeFilter(this);
gf = new GaussianFilter(this);
tf = new ThresholdFilter(this);
}
void OnRenderImage(RenderTexture source, RenderTexture destination)
{
bool isStatic = _blurFreq == BlurFrequency.STATIC;
if (isStatic && Time.renderedFrameCount != 0)
{
Graphics.Blit(source, destination);
return;
}
if (Time.renderedFrameCount % ((int)_blurFreq) == 0)
{
RenderTexture[] rts =
{
BlurTex1, BlurTex2, BlurTex3, BlurTex4
};
BlurFilter filter;
for (int i = 0; i < 4; ++i)
{
if (_filterType == FilterType.GAUSSIAN)
{
filter = new GaussianFilter(GaussianWeights, GaussianOffsets, DownsampleFactors[i]);
}
else
{
filter = new KawaseFilter(0.5f * i, DownsampleFactors[i]);
}
// Execute the filter onto textures rts[i]
filter.execute((i == 0 ? source : rts[i - 1]), rts[i]);
}
}
Graphics.Blit(source, destination);
}
private void гауссовоРазмытиеToolStripMenuItem_Click(object sender, EventArgs e)
{
Filters filter = new GaussianFilter();
backgroundWorker1.RunWorkerAsync(filter);
}
public CircleHoughTransform(byte[,] pixels)
{
var gaussianFilter = new GaussianFilter(5, 1);
var imageSmoothing = new ImageSmoothing(pixels);
var smoothedPixels = imageSmoothing.SmoothImage(gaussianFilter);
}
// Tags aren't reported until we ask for them.
// This method is called asynchronously when we get a report.
static void OnTagsReported(ImpinjReader sender, TagReport report)
{
foreach (Tag tag in report)
{
string epc = tag.Epc.ToString().Replace(" ", String.Empty);
if (!SolutionConstants.tagIds.Contains(epc))
{
continue;
}
DateTime time = DateTime.Now;
// Get the phase angle to determine velocity.
double phaseAngle = tag.PhaseAngleInRadians;
// Mod by PI to overcome reader hardware errors.
phaseAngle = phaseAngle % Math.PI;
// Get the RSSI (received signal stength intensity) to determine position.
double rssi = tag.PeakRssiInDbm;
double channelInHz = tag.ChannelInMhz * 1e6;
double timeInTicks = (double)time.Ticks;
double timeInSec = timeInTicks / (TimeSpan.TicksPerMillisecond * MilliSecPerSeconds);
// Add phase and channel data to a file.
// We will do analysis on the phase angles within a channel over time,
// and for the phases vs. channels.
// Collect multiple times, once with tag not moving, once with tag moving up, and once with tag moving down.
if (epc == testEPC)
{
string data = timeInSec.ToString() + " " + channelInHz.ToString() + " " + phaseAngle.ToString();
// addLineToCSV(phase_csv, data);
}
// If we haven't seen this tag before, initialize dictionaries for it.
if (!lastTimeDict.Keys.Contains(epc))
{
lastTimeDict.TryAdd(epc, timeInSec);
lastPhaseAngleDict.TryAdd(epc, phaseAngle);
lastDeltaPhiDict.TryAdd(epc, 0.0);
lastRSSIDict.TryAdd(epc, rssi);
channelDict.TryAdd(epc, channelInHz);
VelocityFilterDict[epc] = new GaussianFilter(new Normal(0.0, 1e-5));
TouchFilterDict[epc] = new BernoulliFilter(new Bernoulli(.5), NUMTAGS);
return;
}
// Get time between reads.
double lastTime;
lastTimeDict.TryGetValue(epc, out lastTime);
double deltaTimeInSec = timeInSec - lastTime;
// plot("deltaT", timeInSec, deltaTimeInSec);
if (deltaTimeInSec <= 0)
{
Console.WriteLine("deltaTimeInSec less than or equal to 0");
continue;
}
updateTimeBetweenReadsDictionary(epc, timeInSec, deltaTimeInSec);
updateVelocityDictionary(epc, timeInSec, phaseAngle, channelInHz, deltaTimeInSec);
updateRSSIDictionary(epc, rssi);
// Update dictionaries containing previous information.
updateLastDictionaries(epc, phaseAngle, timeInSec, rssi);
if (count % printFrequency == 1 && epc == testEPC)
{
//printUpdatedDictionaries(epc);
}
count += 1;
}
}
public byte[,] SmoothImage(GaussianFilter gaussianFilter)
{
var halfMaskWidth = gaussianFilter.Size / 2;
var intermediatePixels = new double[_maxColumnIndex + 1, _maxRowIndex + 1];
for (var y = 0; y <= _maxRowIndex; ++y)
{
for (var x = 0; x <= _maxColumnIndex; ++x)
{
for (var m = -halfMaskWidth; m <= halfMaskWidth; ++m)
{
double pixel;
if (m + x < 0)
{
pixel = _pixels[0, y];
}
else if (m + x > _maxColumnIndex)
{
pixel = _pixels[_maxColumnIndex, y];
}
else
{
pixel = _pixels[m + x, y];
}
intermediatePixels[x, y] += pixel * gaussianFilter.Filter[m + halfMaskWidth];
}
}
}
var smoothPixels = new double[_maxColumnIndex + 1, _maxRowIndex + 1];
for (var x = 0; x <= _maxColumnIndex; ++x)
{
for (var y = 0; y <= _maxRowIndex; ++y)
{
for (var m = -halfMaskWidth; m <= halfMaskWidth; ++m)
{
double pixel;
if (m + y < 0)
{
pixel = intermediatePixels[x, 0];
}
else if (m + y > _maxRowIndex)
{
pixel = intermediatePixels[x, _maxRowIndex];
}
else
{
pixel = intermediatePixels[x, m + y];
}
smoothPixels[x, y] += pixel * gaussianFilter.Filter[m + halfMaskWidth];
}
}
}
var smoothBytePixels = new byte[_maxColumnIndex + 1, _maxRowIndex + 1];
for (var x = 0; x <= _maxColumnIndex; ++x)
{
for (var y = 0; y <= _maxRowIndex; ++y)
{
smoothBytePixels[x, y] = (byte)smoothPixels[x, y];
}
}
return(smoothBytePixels);
}
public override void ApplayObjectDetection(_Image ApplayImage)
{
_Image XsobelImage = new _Image();
XsobelImage.SetImageLocation(ApplayImage.ImageLocation, true);
// Applaying x-Sobel Opreator
X_Sobel xsolbel = new X_Sobel();
xsolbel.ApplayFilter(XsobelImage);
_Image YsobelImage = new _Image();
YsobelImage.SetImageLocation(ApplayImage.ImageLocation, true);
// Applaying Y-sobel Opreator
Y_Sobel ysobel = new Y_Sobel();
ysobel.ApplayFilter(YsobelImage);
double[,] XsolbelArray = SquerBitmap(XsobelImage.GetFilterdImageBitMap());
double[,] YsolbelArray = SquerBitmap(YsobelImage.GetFilterdImageBitMap());
YsobelImage.ReplaceMainImageWithiltedImage();
XsobelImage.ReplaceMainImageWithiltedImage();
// Get The Multipication OF 2 Image
string Message = "";
Bitmap MultBitMap = HelperFunctions.MultibleTwoImage(XsobelImage.GetFilterdImageBitMap(), YsobelImage.GetFilterdImageBitMap(), out Message);
_Image MultiImage = new _Image();
MultiImage.SetFilterdBitMap(ref MultBitMap);
MultiImage.ReplaceMainImageWithiltedImage();
// Applay Gaussian Filter
GaussianFilter NewFilter = new GaussianFilter();
NewFilter.Sigma = 2;
NewFilter.KernalSize = 7;
NewFilter.ApplayFilter(XsobelImage);
NewFilter.ApplayFilter(YsobelImage);
NewFilter.ApplayFilter(MultiImage);
Bitmap SobelXBitMap = XsobelImage.GetFilterdImageBitMap();
Bitmap SobelyBitMap = YsobelImage.GetFilterdImageBitMap();
MainImage = ApplayImage.GetMainImage();
ImageBitMap = new Bitmap(MainImage);
int imageWidth = ApplayImage.ImageWidth, ImageHieght = ApplayImage.ImageHeight;
double[,] Result = new double[ImageHieght, imageWidth];
double[,] R = new double[ImageHieght, imageWidth];
double Rmax = double.MinValue;
for (int i = 0; i < ImageHieght; i++)
{
for (int j = 0; j < imageWidth; j++)
{
double det = (SobelXBitMap.GetPixel(i, j).R *SobelyBitMap.GetPixel(i, j).R) - (MultBitMap.GetPixel(i, j).R *MultBitMap.GetPixel(i, j).R);
double trace = (SobelXBitMap.GetPixel(i, j).R + SobelyBitMap.GetPixel(i, j).R);
R[i, j] = det - (trace * trace / 100);
if (R[i, j] > Rmax)
{
Rmax = R[i, j];
}
//int RGB = (int)R[i, j];
//ImageBitMap.SetPixel(i, j, Color.FromArgb(RGB , RGB , RGB));
}
}
int count = 0;
for (int i = 2; i < ImageHieght - 1; i++)
{
for (int j = 2; j < imageWidth - 1; j++)
{
if ((R[i, j] > Rmax / 10) && (R[i, j] > R[i - 1, j - 1]) && (R[i, j] > R[i - 1, j]) && (R[i, j] > R[i - 1, j + 1]) && (R[i, j] > R[i, j - 1]) && (R[i, j] > R[i, j + 1]) && (R[i, j] > R[i + 1, j - 1]) && (R[i, j] > R[i + 1, j]) && (R[i, j] > R[i + 1, j + 1]))
{
ImageBitMap.SetPixel(i, j, Color.Red);
count++;
}
//if (R[i, j] > 0.1 * Rmax && R[i, j] > R[i - 1, j - 1] && R[i, j] > R[i - 1, j] && R[i, j] > R[i - 1, j + 1] && R[i, j] > R[i, j - 1] && R[i, j] > R[i, j + 1] && R[i, j] > R[i + 1, j - 1] && R[i, j] > R[i + 1, j] && R[i, j] > R[i + 1, j + 1])
//{
// //Result[i, j] = 1;
// ImageBitMap.SetPixel(i, j, Color.Red);
// count++;
//}
}
}
Console.WriteLine(count);
ApplayImage.SetFilterdBitMap(ref ImageBitMap);
}
