/// <summary>
/// Gets the hash code
/// </summary>
/// <returns>Hash code</returns>
public override int GetHashCode()
{
unchecked // Overflow is fine, just wrap
{
int hashCode = 41;
if (FileId != null)
{
hashCode = hashCode * 59 + FileId.GetHashCode();
}
if (PageRange != null)
{
hashCode = hashCode * 59 + PageRange.GetHashCode();
}
hashCode = hashCode * 59 + RoiLeft.GetHashCode();
hashCode = hashCode * 59 + RoiTop.GetHashCode();
hashCode = hashCode * 59 + RoiWidth.GetHashCode();
hashCode = hashCode * 59 + RoiHeight.GetHashCode();
hashCode = hashCode * 59 + GammaCorrection.GetHashCode();
hashCode = hashCode * 59 + Brightness.GetHashCode();
hashCode = hashCode * 59 + Contrast.GetHashCode();
hashCode = hashCode * 59 + Saturation.GetHashCode();
hashCode = hashCode * 59 + AutoContrastEnhancement.GetHashCode();
hashCode = hashCode * 59 + ContrastHistogramStretch.GetHashCode();
return(hashCode);
}
}
public Bitmap ToGammaCorrection(Bitmap Im)
{
AForge.Imaging.Filters.GammaCorrection Img = new GammaCorrection();
Bitmap bmImage = AForge.Imaging.Image.Clone(new Bitmap(Im), PixelFormat.Format24bppRgb);
return(Img.Apply(bmImage));
}
/// <summary>
/// Returns true if ImageAdjustParameters instances are equal
/// </summary>
/// <param name="input">Instance of ImageAdjustParameters to be compared</param>
/// <returns>Boolean</returns>
public bool Equals(ImageAdjustParameters input)
{
if (input == null)
{
return(false);
}
return
((
FileId == input.FileId ||
(FileId != null &&
FileId.Equals(input.FileId))
) &&
(
PageRange == input.PageRange ||
(PageRange != null &&
PageRange.Equals(input.PageRange))
) &&
(
RoiLeft == input.RoiLeft ||
RoiLeft.Equals(input.RoiLeft)
) &&
(
RoiTop == input.RoiTop ||
RoiTop.Equals(input.RoiTop)
) &&
(
RoiWidth == input.RoiWidth ||
RoiWidth.Equals(input.RoiWidth)
) &&
(
RoiHeight == input.RoiHeight ||
RoiHeight.Equals(input.RoiHeight)
) &&
(
GammaCorrection == input.GammaCorrection ||
GammaCorrection.Equals(input.GammaCorrection)
) &&
(
Brightness == input.Brightness ||
Brightness.Equals(input.Brightness)
) &&
(
Contrast == input.Contrast ||
Contrast.Equals(input.Contrast)
) &&
(
Saturation == input.Saturation ||
Saturation.Equals(input.Saturation)
) &&
(
AutoContrastEnhancement == input.AutoContrastEnhancement ||
AutoContrastEnhancement.Equals(input.AutoContrastEnhancement)
) &&
(
ContrastHistogramStretch == input.ContrastHistogramStretch ||
ContrastHistogramStretch.Equals(input.ContrastHistogramStretch)
));
}
/// <summary>
/// Initializes saturation/contrast/exposure/gamma/brightess filter.
/// </summary>
public SaturationContrastBrightnessFilter()
{
this.ce = new ContrastEnhancement(0, Space.YCbCr);
this.sc = new SaturationCorrection(0);
this.bc = new BrightnessCorrection(0, Space.YCbCr);
this.ec = new ShiftCorrection(0, Space.YCbCr);
this.gc = new GammaCorrection(0, Space.YCbCr);
}
public mAdjustGamma(double gamma)
{
Gamma = gamma;
BitmapType = BitmapTypes.Rgb24bpp;
filter = new GammaCorrection(Gamma);
}
/// <summary>
/// Initializes a new instance of the <see cref="PrototypeViewModel"/> class.
/// </summary>
public PrototypeViewModel()
{
_testAlg = new Algorithm();
_smooth = new GaussianSmooth();
_correct = new GammaCorrection();
_testAlg.Add(_smooth);
_testAlg.Add(_correct);
_processCmd = new ProcessImageCommand(_testAlg);
_processCmd.ImageProcessed += image_processed;
}
public static Vector3 GetProceduralColor(double x, double y, double z)
{
if (((x - Math.Truncate(x)) + (y - Math.Truncate(y)) + (z - Math.Truncate(z))) < 0.5)
{
return(new Vector3(GammaCorrection.ConvertAndClampAndGammaCorrect(1.0f), 0, 0));
}
else
{
return(new Vector3(0, 0, 0));
}
}
public void processImage()
{
//Snaps an image from videoSourcePlayer1 and adjusts gama and contrast based on slider bars(gamaSlider and contrastSlider)
Bitmap capturedImage = videoSourcePlayer1.GetCurrentVideoFrame();
workingImage = capturedImage;
GammaCorrection gamaFilter = new GammaCorrection((gamaSlider.Value) / 100.0);
ContrastCorrection contrastFilter = new ContrastCorrection((contrastSlider.Value));
workingImage = gamaFilter.Apply(workingImage);
workingImage = contrastFilter.Apply(workingImage);
}
public static Bitmap Sketch(Bitmap image)
{
var layerA = new SaturationCorrection(-71).Apply(image);
var layerB = new Invert().Apply(layerA);
layerB = new GaussianBlur().Apply(layerB);
layerA = new BlendFilter(BlendMode.ColorDodge, layerB).Apply(layerA);
layerA = new GammaCorrection(-5).Apply(layerA);
//layerA = new BlendFilter(BlendMode.Overlay, layerA).Apply(image);
return(layerA);
}
public void doGamma(int gamma)
{
Bitmap img = new Bitmap(path);
GammaCorrection filter = new GammaCorrection((gamma / 10));
// apply the filter
img = filter.Apply(img);
// ImageEView
if (mov != null)
{
this.WorkItem.Workspaces[WorkspaceNames.TabWorkspace].Close(mov);
}
mov = this.WorkItem.SmartParts.AddNew <ImageEView>();
mov.panAndZoomPictureBox1.Image = img;
SmartPartInfo spi =
new SmartPartInfo("Gamma Correction", "MyOwnDescription");
this.WorkItem.Workspaces[WorkspaceNames.TabWorkspace].Show(mov, spi);
}
public Vector3 GetBitmapColor(double x, double y, double z)
{
double s = Math.Atan2(x, -z);
double t = Math.Acos(-y);
// Get Color from bitmap
int u = (int)(t / (Math.PI) * bitmap.Width);
int v = (int)((s + Math.PI) / (2 * Math.PI) * bitmap.Height);
if (u > 0 && u < bitmap.Width && v > 0 && v < bitmap.Height)
{
Color c = bitmap.GetPixel(u, v);
Vector3 bitMapColor = Vector3.Normalize(new Vector3(GammaCorrection.ConvertAndClampAndGammaCorrect(c.R), GammaCorrection.ConvertAndClampAndGammaCorrect(c.G), GammaCorrection.ConvertAndClampAndGammaCorrect(c.B)));
return(bitMapColor);
}
else
{
return(new Vector3(0, 0, 0)); // Black
}
}
private void Video_NewFrame(object sender, NewFrameEventArgs eventArgs)
{
brightness = new BrightnessCorrection(brightValue);
contrast = new ContrastCorrection(contrastValue);
gamma = new GammaCorrection(gammaValue);
Bitmap image = (Bitmap)eventArgs.Frame.Clone();
Graphics graphics = Graphics.FromImage(image);
using (Pen pen = new Pen(Color.Green, 7))
{
//Top, left
graphics.DrawLine(pen, 80, 28, 100, 28);
graphics.DrawLine(pen, 80, 28, 80, 48);
//Top, right
graphics.DrawLine(pen, 80 + 146, 28, 80 + 126, 28);
graphics.DrawLine(pen, 80 + 146, 28, 80 + 146, 48);
//Bottom, left
graphics.DrawLine(pen, 80, 35 + 171, 100, 35 + 171);
graphics.DrawLine(pen, 80, 35 + 171, 80, 35 + 151);
//Bottom, right
graphics.DrawLine(pen, 80 + 146, 35 + 171, 80 + 126, 35 + 171);
graphics.DrawLine(pen, 80 + 146, 35 + 171, 80 + 146, 35 + 151);
//Middle left size
graphics.DrawLine(pen, 80, 113, 80, 113 + 20);
//Middle right size
graphics.DrawLine(pen, 80 + 146, 113, 80 + 146, 113 + 20);
//Middle top size
graphics.DrawLine(pen, 146, 28, 166, 28);
//Middle botom size
graphics.DrawLine(pen, 146, 35 + 171, 166, 35 + 171);
//graphics.DrawRectangle(pen, rectangle);
}
ptbImage.Image = brightness.Apply(gamma.Apply(contrast.Apply(image)));
//ptbImage.Image = image;
lblBrightness.Text = brightValue.ToString();
lblContrast.Text = contrastValue.ToString();
lblGamma.Text = gammaValue.ToString();
}
public Image ProcessImage(Image input, ProjectSetting ps)
{
Bitmap image = new Bitmap(input);
if (input.PixelFormat != PixelFormat.Format24bppRgb &&
input.PixelFormat != PixelFormat.Format16bppGrayScale &&
input.PixelFormat != PixelFormat.Format8bppIndexed)
{
// Aforge library only support certian bpp, need to do a convert first
image = this.ChangePixelFormat(image, PixelFormat.Format24bppRgb);
}
var layerA = new SaturationCorrection(-71).Apply(image);
var layerB = new Invert().Apply(layerA);
layerB = new GaussianBlur().Apply(layerB);
layerA = new BlendFilter(BlendMode.ColorDodge, layerB).Apply(layerA);
layerA = new GammaCorrection(-5).Apply(layerA);
//layerA = new BlendFilter(BlendMode.Overlay, layerA).Apply(image);
return((Image)layerA);
}
public void PrintScene()
{
byte[] colourData = new byte[image.PixelHeight * image.PixelWidth * bytesPerPixel];
for (int x = 0; x < image.PixelWidth; x++)
{
for (int y = 0; y < image.PixelHeight; y++)
{
Vector3 color = Vector3.Zero;
for (int i = 0; i < antiAliasing; i++)
{
float tmp_x = (float)rd.RandomGauss(x, 0.5f);
float tmp_y = (float)rd.RandomGauss(y, 0.5f);
Vector2 coord = new Vector2((float)2.0 / image.PixelWidth * tmp_x - 1, (float)2.0 / image.PixelHeight * tmp_y - 1);
if (checkBoxControl.ISBVHAccelerationCheckBoxChecked)
{
color += bhvScene.CalcColour(checkBoxControl, bhvScene.CreateEyeRay(coord));
}
else
{
color += scene.CalcColour(checkBoxControl, scene.CreateEyeRay(coord));
}
}
color = color / antiAliasing;
colourData[(x * bytesPerPixel + y * image.PixelHeight * bytesPerPixel)] = GammaCorrection.ConvertAndClampAndGammaCorrect(color.X); // Red
colourData[(x * bytesPerPixel + y * image.PixelHeight * bytesPerPixel + 1)] = GammaCorrection.ConvertAndClampAndGammaCorrect(color.Y); // Blue
colourData[(x * bytesPerPixel + y * image.PixelHeight * bytesPerPixel + 2)] = GammaCorrection.ConvertAndClampAndGammaCorrect(color.Z); // Green
}
}
image.Lock();
image.WritePixels(new Int32Rect(0, 0, image.PixelWidth, image.PixelHeight), colourData, image.PixelWidth * bytesPerPixel, 0);
image.Unlock();
img.Source = image;
}
public static byte[] ApplyFilter(byte[] imageBytes, ImageProcessingFilters filter, ImageFormat format = null)
{
IFilter baseFilter = null;
switch (filter)
{
case ImageProcessingFilters.Default:
return(imageBytes);
case ImageProcessingFilters.GrayscaleBT709:
baseFilter = new GrayscaleBT709();
break;
case ImageProcessingFilters.GrayscaleRMY:
baseFilter = new GrayscaleRMY();
break;
case ImageProcessingFilters.GrayscaleY:
baseFilter = new GrayscaleY();
break;
case ImageProcessingFilters.BayerFilter:
baseFilter = new FiltersSequence();
((FiltersSequence)baseFilter).Add(new ExtractChannel(RGB.B));
((FiltersSequence)baseFilter).Add(new BayerFilter());
break;
/*
* case ImageProcessingFilters.ImageWarp:
* baseFilter = new ImageWarp(
* break;
* */
case ImageProcessingFilters.Channel_Red:
baseFilter = new ExtractChannel(RGB.R);
break;
case ImageProcessingFilters.Channel_Green:
baseFilter = new ExtractChannel(RGB.G);
break;
case ImageProcessingFilters.Channel_Blue:
baseFilter = new ExtractChannel(RGB.B);
break;
case ImageProcessingFilters.WaterWave:
baseFilter = new WaterWave();
((WaterWave)baseFilter).HorizontalWavesCount = 10;
((WaterWave)baseFilter).HorizontalWavesAmplitude = 5;
((WaterWave)baseFilter).VerticalWavesCount = 3;
((WaterWave)baseFilter).VerticalWavesAmplitude = 15;
break;
case ImageProcessingFilters.Sepia:
baseFilter = new Sepia();
break;
case ImageProcessingFilters.BrightnessCorrection:
baseFilter = new BrightnessCorrection(-50);
break;
case ImageProcessingFilters.ContrastCorrection:
baseFilter = new ContrastCorrection(15);
break;
case ImageProcessingFilters.SaturationCorrection1:
baseFilter = new SaturationCorrection(-0.5f);
break;
case ImageProcessingFilters.SaturationCorrection2:
baseFilter = new SaturationCorrection(-.25f);
break;
case ImageProcessingFilters.SaturationCorrection3:
baseFilter = new SaturationCorrection(+0.5f);
break;
case ImageProcessingFilters.Invert:
baseFilter = new Invert();
break;
case ImageProcessingFilters.Blur:
baseFilter = new Blur();
break;
case ImageProcessingFilters.RotateChannels:
baseFilter = new RotateChannels();
break;
case ImageProcessingFilters.RotateChannels2:
baseFilter = new FiltersSequence();
((FiltersSequence)baseFilter).Add(new RotateChannels());
((FiltersSequence)baseFilter).Add(new RotateChannels());
break;
case ImageProcessingFilters.AdditiveNoise:
IRandomNumberGenerator generator = new UniformGenerator(new Range(-50, 50));
baseFilter = new AdditiveNoise(generator);
break;
case ImageProcessingFilters.GammaCorrection:
baseFilter = new GammaCorrection(0.5);
break;
case ImageProcessingFilters.HistogramEqualization:
baseFilter = new HistogramEqualization();
break;
case ImageProcessingFilters.OrderedDithering:
byte[,] matrix = new byte[4, 4]
{
{ 95, 233, 127, 255 },
{ 159, 31, 191, 63 },
{ 111, 239, 79, 207 },
{ 175, 47, 143, 15 }
};
baseFilter = new FiltersSequence();
((FiltersSequence)baseFilter).Add(new GrayscaleBT709());
((FiltersSequence)baseFilter).Add(new OrderedDithering(matrix));
break;
case ImageProcessingFilters.Pixallete:
baseFilter = new Pixellate();
break;
case ImageProcessingFilters.SimplePosterization:
baseFilter = new SimplePosterization();
break;
case ImageProcessingFilters.Texturer_Textile:
baseFilter = new Texturer(new AForge.Imaging.Textures.TextileTexture(), 0.3, 0.7);
break;
case ImageProcessingFilters.Texturer_Cloud:
baseFilter = new Texturer(new AForge.Imaging.Textures.CloudsTexture(), 0.3, 0.7);
break;
case ImageProcessingFilters.Texturer_Marble:
baseFilter = new Texturer(new AForge.Imaging.Textures.MarbleTexture(), 0.3, 0.7);
break;
case ImageProcessingFilters.Texturer_Wood:
baseFilter = new Texturer(new AForge.Imaging.Textures.WoodTexture(), 0.3, 0.7);
break;
case ImageProcessingFilters.Texturer_Labyrinth:
baseFilter = new Texturer(new AForge.Imaging.Textures.LabyrinthTexture(), 0.3, 0.7);
break;
case ImageProcessingFilters.SobelEdgeDetector:
baseFilter = new FiltersSequence();
((FiltersSequence)baseFilter).Add(new ExtractChannel(RGB.R));
((FiltersSequence)baseFilter).Add(new SobelEdgeDetector());
break;
case ImageProcessingFilters.SobelEdgeDetectorInvert:
baseFilter = new FiltersSequence();
((FiltersSequence)baseFilter).Add(new ExtractChannel(RGB.R));
((FiltersSequence)baseFilter).Add(new SobelEdgeDetector());
((FiltersSequence)baseFilter).Add(new Invert());
break;
case ImageProcessingFilters.SobelEdgeDetectorSepia:
baseFilter = new FiltersSequence();
((FiltersSequence)baseFilter).Add(new ExtractChannel(RGB.R));
((FiltersSequence)baseFilter).Add(new SobelEdgeDetector());
((FiltersSequence)baseFilter).Add(new GrayscaleToRGB());
((FiltersSequence)baseFilter).Add(new Sepia());
break;
case ImageProcessingFilters.SobelEdgeDetectorSepiaCanvas:
baseFilter = new FiltersSequence();
((FiltersSequence)baseFilter).Add(new ExtractChannel(RGB.R));
((FiltersSequence)baseFilter).Add(new SobelEdgeDetector());
((FiltersSequence)baseFilter).Add(new GrayscaleToRGB());
((FiltersSequence)baseFilter).Add(new Sepia());
((FiltersSequence)baseFilter).Add(new SimplePosterization());
((FiltersSequence)baseFilter).Add(new Texturer(new AForge.Imaging.Textures.TextileTexture(), 0.3, 0.7));
break;
case ImageProcessingFilters.Drawing:
baseFilter = new FiltersSequence();
((FiltersSequence)baseFilter).Add(new GrayscaleBT709());
((FiltersSequence)baseFilter).Add(new SobelEdgeDetector());
((FiltersSequence)baseFilter).Add(new Invert());
((FiltersSequence)baseFilter).Add(new SimplePosterization());
break;
case ImageProcessingFilters.DrawingSepia:
baseFilter = new FiltersSequence();
((FiltersSequence)baseFilter).Add(new GrayscaleBT709());
((FiltersSequence)baseFilter).Add(new SobelEdgeDetector());
((FiltersSequence)baseFilter).Add(new Invert());
((FiltersSequence)baseFilter).Add(new SimplePosterization());
((FiltersSequence)baseFilter).Add(new GrayscaleToRGB());
((FiltersSequence)baseFilter).Add(new Sepia());
break;
case ImageProcessingFilters.OilCanvas:
baseFilter = new FiltersSequence();
((FiltersSequence)baseFilter).Add(new SimplePosterization());
((FiltersSequence)baseFilter).Add(new Texturer(new AForge.Imaging.Textures.TextileTexture(), 0.3, 0.7));
break;
case ImageProcessingFilters.OilCanvasGray:
baseFilter = new FiltersSequence();
((FiltersSequence)baseFilter).Add(new SimplePosterization());
((FiltersSequence)baseFilter).Add(new Texturer(new AForge.Imaging.Textures.TextileTexture(), 0.3, 0.7));
((FiltersSequence)baseFilter).Add(new GrayscaleBT709());
break;
case ImageProcessingFilters.OilCanvasSepia:
baseFilter = new FiltersSequence();
((FiltersSequence)baseFilter).Add(new SimplePosterization());
((FiltersSequence)baseFilter).Add(new Texturer(new AForge.Imaging.Textures.TextileTexture(), 0.3, 0.7));
((FiltersSequence)baseFilter).Add(new Sepia());
break;
}
if (baseFilter == null)
{
return(null);
}
return(ApplyFilter(imageBytes, baseFilter, format));
}
public MainForm()
{
InitializeComponent();
#region settings
settings = new SettingsProviderXML <SettingsContainer>();
settings.Load(Path.ChangeExtension(Application.ExecutablePath, "settings"));
#endregion
#region encoder
encoder = new Encoder(settings.Data.SampleRateHz, settings.Data.FFTSize, frameSize, StartLine, rMask);
#endregion
#region
startFrequencyTrk.Minimum = 0;
startFrequencyTrk.Maximum = settings.Data.FFTSize / 2 - 128;
StartLine = 60;
startFrequencyTrk_ValueChanged(startFrequencyTrk, new EventArgs());
#endregion
#region framePostFilter
gammaCorrector = new GammaCorrection(1.5);
resizer = new ResizeBicubic(outFrameSize.Width, outFrameSize.Height);
framePostFilter = new FiltersSequence(new IFilter[]
{
Grayscale.CommonAlgorithms.RMY,
gammaCorrector,
resizer
});
gammaFactorTrk.Value = 150;
gammaFactorTrk_ValueChanged(gammaFactorTrk, new EventArgs());
#endregion
#region receiver
for (int n = 0; n < WaveIn.DeviceCount; n++)
{
audioInputDeviceCbx.Items.Add(WaveIn.GetCapabilities(n).ProductName);
}
if (audioInputDeviceCbx.Items.Count > 0)
{
receiverExists = true;
audioInputDeviceCbx.SelectedIndex = 0;
audioInputDeviceCbx_SelectedIndexChanged(audioInputDeviceCbx, new EventArgs());
receiverBtn.Enabled = true;
}
#endregion
#region transmitter
transmitter = new Transmitter(encoder, 2, 4, 5);
transmitter.FrameTransmitted += new EventHandler <NextFrameEventArgs>(transmitter_FrameTransmitted);
transmitter.TransmissionStarted += new EventHandler(transmitter_TransmissionStarted);
transmitter.TransmissionStopped += new EventHandler(transmitter_TransmissionStopped);
#endregion
#region vDevice
videoDevices = new FilterInfoCollection(FilterCategory.VideoInputDevice);
for (int i = 0; i < videoDevices.Count; i++)
{
videoCaptureDeviceCbx.Items.Add(videoDevices[i].Name);
}
if (videoCaptureDeviceCbx.Items.Count > 0)
{
videoCaptureDeviceCbx.SelectedIndex = 0;
videoCaptureDeviceCbx_SelectedIndexChanged(new object(), new EventArgs());
videoCaptureBtn.Enabled = true;
}
#endregion
}
public Bitmap AutoCorrection(Bitmap img)
{
GammaCorrection filter = new GammaCorrection(0.5);
return(filter.Apply(img));
}
