//######################################################################################################################################################## public static void decomprassion2(ref RGBPixel[,] ImageMatrix, List <string> r_code, List <string> g_code, List <string> b_code, List <int> r_v, List <int> g_v, List <int> b_v) { char ch; StreamReader reader; FileInfo ff = new FileInfo("comprass.txt"); int gg = (int)ff.Length; BitArray b2 = new BitArray(gg * 8); int index1 = 0; int index = -1; reader = new StreamReader("comprass.txt"); while (!reader.EndOfStream) { ch = (char)reader.Read(); byte bn = (byte)ch; BitArray bc = new BitArray(new byte[] { bn }); for (int ii = 0; ii < 8; ii++) { b2[index1] = bc[ii]; index1++; } } reader.Close(); for (int i = 0; i < ImageMatrix.GetLength(0); i++) { for (int f = 0; f < ImageMatrix.GetLength(1); f++) { ImageMatrix[i, f].red = decomprss2(r_code, r_v, b2, ref index); ImageMatrix[i, f].green = decomprss2(g_code, g_v, b2, ref index); ImageMatrix[i, f].blue = decomprss2(b_code, b_v, b2, ref index); } } }
public HuffmanTree(RGBPixel[,] Image, long seed, short tap, short size) { //initializations total_memory_bytes = 0; RedFreqs = new int[256]; GreenFreqs = new int[256]; BlueFreqs = new int[256]; huffmancodesred = new string[256]; huffmancodesgreen = new string[256]; huffmancodesblue = new string[256]; RedNodes = new PriorityQueue <int, Node>(); GreenNodes = new PriorityQueue <int, Node>(); BlueNodes = new PriorityQueue <int, Node>(); total_memory_bytes = 3 * Image.GetLength(0) * Image.GetLength(1); for (int i = 0; i < Image.GetLength(0); i++) { for (int j = 0; j < Image.GetLength(1); j++) { RedFreqs[Image[i, j].red]++; GreenFreqs[Image[i, j].green]++; BlueFreqs[Image[i, j].blue]++; } } ConstructHuffmanTree(); Print_log(Image, seed, tap, size); }
/// <summary> /// Display the given image on the given PictureBox object /// </summary> /// <param name="ImageMatrix">2D array that contains the image</param> /// <param name="PicBox">PictureBox object to display the image on it</param> public static void DisplayImage(RGBPixel[,] ImageMatrix, PictureBox PicBox) { // Create Image: //============== int Height = ImageMatrix.GetLength(0); int Width = ImageMatrix.GetLength(1); Bitmap ImageBMP = new Bitmap(Width, Height, PixelFormat.Format24bppRgb); unsafe { BitmapData bmd = ImageBMP.LockBits(new Rectangle(0, 0, Width, Height), ImageLockMode.ReadWrite, ImageBMP.PixelFormat); int nWidth = 0; nWidth = Width * 3; int nOffset = bmd.Stride - nWidth; byte *p = (byte *)bmd.Scan0; for (int i = 0; i < Height; i++) { for (int j = 0; j < Width; j++) { p[2] = ImageMatrix[i, j].red; p[1] = ImageMatrix[i, j].green; p[0] = ImageMatrix[i, j].blue; p += 3; } p += nOffset; } ImageBMP.UnlockBits(bmd); } PicBox.Image = ImageBMP; }
private void btnOpen_Click(object sender, EventArgs e) { OpenFileDialog openFileDialog1 = new OpenFileDialog(); if (openFileDialog1.ShowDialog() == DialogResult.OK) { reset(); init(); //Open the browsed image and display it string OpenedFilePath = openFileDialog1.FileName; ImageMatrix = ImageOperations.OpenImage(OpenedFilePath); helper.set_boundries(ImageMatrix.GetLength(0), ImageMatrix.GetLength(1)); // row , col /* * I think this step just have the aim of getting the pixel of where the */ ImageOperations.DisplayImage(ImageMatrix, pictureBox1); int sz = ImageMatrix.GetLength(0) * ImageMatrix.GetLength(1); g = new graph(sz); // special case of init(); g.set_width(ImageMatrix.GetLength(1)); // 1 is width = number of columns //g.build(ImageMatrix); // cuz time delay ok = true; } // GUI Stuff txtWidth.Text = ImageOperations.GetWidth(ImageMatrix).ToString(); txtHeight.Text = ImageOperations.GetHeight(ImageMatrix).ToString(); }
private void computeFrequencies(RGBPixel[,] arr, ref Dictionary <byte, int> temp1, ref Dictionary <byte, int> temp2, ref Dictionary <byte, int> temp3) { for (int i = 0; i < arr.GetLength(0); i++) { for (int j = 0; j < arr.GetLength(1); j++) { if (temp1.ContainsKey(arr[i, j].red)) { temp1[arr[i, j].red]++; } else { temp1.Add(arr[i, j].red, 1); } if (temp2.ContainsKey(arr[i, j].blue)) { temp2[arr[i, j].blue]++; } else { temp2.Add(arr[i, j].blue, 1); } if (temp3.ContainsKey(arr[i, j].green)) { temp3[arr[i, j].green]++; } else { temp3.Add(arr[i, j].green, 1); } } } }
public static void get_Distincit(RGBPixel[,] M)//function to get the distincit nodes and take given matrix of image { /* * Total complexty = theta (w*h) = theta (N^2) */ nodes = new List <int>(); //intitialize the distincit list HashSet <int> Vertices = new HashSet <int>(); //hashset to check if node is already exist MST = new List <GRAPH>(); //initialize Minimum spaning tree list int h = M.GetLength(0), w = M.GetLength(1); // get width and height of image for (int i = 0; i < h; i++) { for (int j = 0; j < w; j++) { int ind1 = M[i, j].red << 8 | M[i, j].green; int ind = ind1 << 8 | M[i, j].blue; /*shifting the red and green and blue in integer and work as integer this is much faster than * making it RGBPixel due to much of collision of hashset as it use hash function */ if (Vertices.Add(ind)) //if this node is not already taken before then add it to hashset and { nodes.Add(ind); // add it as it is distincit color MST.Add(new GRAPH(ind, ind, (float)10000000)); //initialize itself in Minimum spanning tree as it go from itself to itself with large value } //if } //inner for } //outer for } //get_distincit
public static int get_distinct(ref RGBPixel[,] Buffer) { bool[, ,] visited_buffer = new bool[256, 256, 256]; RGBPixel new_one; distinct = new List <RGBPixel>(); int rw = Buffer.GetLength(0); int cl = Buffer.GetLength(1); for (int row = 0; row < rw; row++) { for (int col = 0; col < cl; col++) { new_one = Buffer[row, col]; if (visited_buffer[new_one.red, new_one.green, new_one.blue] == false) { visited_buffer[new_one.red, new_one.green, new_one.blue] = true; distinct.Add(new_one); } } } MessageBox.Show(distinct.Count.ToString()); return(distinct.Count); }
/// <summary> /// Gets the distinct colors from the matrix of colors /// </summary> /// <returns>Set of colors</returns> public static void GetDistinct(RGBPixel[,] M) { width = M.GetLength(0); height = M.GetLength(1); distinctHashtable = new Hashtable(); distinctColors = new RGBPixel[width * height]; vertixNumber = new int[width, height]; int hashFunctionKey = 0; int Counter = 0; for (int i = 0; i < M.GetLength(0); i++) { for (int j = 0; j < M.GetLength(1); j++) { // Calculates the Key of the hashtable from three integers (red,blue,green) hashFunctionKey = 8 * (M[i, j].green + M[i, j].blue) * (M[i, j].green + M[i, j].blue + 1) + M[i, j].blue; hashFunctionKey = 5 * (hashFunctionKey + M[i, j].red) * (hashFunctionKey + M[i, j].red + 1) + M[i, j].red; if (!distinctHashtable.ContainsKey(hashFunctionKey)) { distinctHashtable.Add(hashFunctionKey, Counter); distinctColors[Counter] = M[i, j]; Counter++; } vertixNumber[i, j] = (int)distinctHashtable[hashFunctionKey]; } } }
private void btnOpen_Click(object sender, EventArgs e) { OpenFileDialog openFileDialog1 = new OpenFileDialog(); if (openFileDialog1.ShowDialog() == DialogResult.OK) { //Open the browsed image and display it string OpenedFilePath = openFileDialog1.FileName; ImageMatrix = ImageOperations.OpenImage(OpenedFilePath); Graph constructed = new Graph(); //constructed = ALL_FUNCTIONS.construct_ALL(ImageMatrix); //Graph MST=ALL_FUNCTIONS.set_MST(constructed); ImageOperations.DisplayImage(ImageMatrix, pictureBox1); int rw = ImageMatrix.GetLength(0), cl = ImageMatrix.GetLength(1); ImageMatrix_Tmp = new RGBPixel[rw, cl]; } txtWidth.Text = ImageOperations.GetWidth(ImageMatrix).ToString(); txtHeight.Text = ImageOperations.GetHeight(ImageMatrix).ToString(); distinct_colors = ALL_FUNCTIONS.get_distinct(ref ImageMatrix); //ALL_FUNCTIONS.test(); ALL_FUNCTIONS.Set_Mst(); // to handl if user input more than one cluster in same image and make operation on original image ImageMatrix_Tmp = ImageMatrix.Clone() as RGBPixel[, ]; }
public static RGBPixel[,] Encrypt_No_cycles(RGBPixel[,] ImageMatrix, short seed_size, short tap_pos, long seed) { RGBPixel[,] ret = new RGBPixel[ImageMatrix.GetLength(0), ImageMatrix.GetLength(1)]; for (int i = 0; i < seed_size - 1; i++) { msk |= (1 << i); } int N = ImageMatrix.GetLength(0); int M = ImageMatrix.GetLength(1); int j = 0; for (int i = 0; i < N; i++) { for (j = 0; j < M; j++) { ret[i, j].red = ImageMatrix[i, j].red; ret[i, j].red ^= get_key_no_cycles(ref seed, tap_pos, seed_size, 8); ret[i, j].green = ImageMatrix[i, j].green; ret[i, j].green ^= get_key_no_cycles(ref seed, tap_pos, seed_size, 8); ret[i, j].blue = ImageMatrix[i, j].blue; ret[i, j].blue ^= get_key_no_cycles(ref seed, tap_pos, seed_size, 8); } } return(ret); }
public static void make_freq(RGBPixel[,] ImageMatrix, ref List <node> fred, ref List <node> fgreen, ref List <node> fblue) { for (int i = 0; i < ImageMatrix.GetLength(0); i++) { for (int g = 0; g < ImageMatrix.GetLength(1); g++) { bool k = false; int x = (int)ImageMatrix[i, g].red; for (int y = 0; y < fred.Count; y++) { int ww = (int)fred[y].value; if (ww == x) { fred[y].freq++; k = true; break; } } if (k == false) { node temp = new node(x, 1); fred.Add(temp); } k = false; x = (int)ImageMatrix[i, g].green; for (int y = 0; y < fgreen.Count; y++) { if (fgreen[y].value == x) { fgreen[y].freq++; k = true; break; } } if (k == false) { node temp = new node(x, 1); fgreen.Add(temp); } k = false; x = (int)ImageMatrix[i, g].blue; for (int y = 0; y < fblue.Count; y++) { if (fblue[y].value == x) { fblue[y].freq++; k = true; break; } } if (k == false) { node temp = new node(x, 1); fblue.Add(temp); } } } }
private void btnGaussSmooth_Click(object sender, EventArgs e) { int tap = Int16.Parse(txtGaussSigma.Text); //ϴ(1) string seed = textBox1.Text; //ϴ(1) // start stopwatch Stopwatch stopWatch = new Stopwatch(); // ϴ(1) stopWatch.Start(); // ϴ(1) TimeSpan ts; // ϴ(1) string elapsedTime; // ϴ(1) RGBPixel[,] image3 = new RGBPixel[ImageMatrix.GetLength(0), ImageMatrix.GetLength(1)]; // ϴ(1) Array.Copy(ImageMatrix, image3, ImageMatrix.GetLength(0) * ImageMatrix.GetLength(1)); // ϴ(N^2) where n is the largest between width and height ImageMatrix = ImageOperations.encrypt(ImageMatrix, tap, seed); // ϴ(N^2) where n is the largest between width and height ImageOperations.DisplayImage(ImageMatrix, pictureBox2); // ϴ(N^2) where n is the largest between width and height ts = stopWatch.Elapsed; // ϴ(1) // Format and display the TimeSpan value. elapsedTime = String.Format("{0:00}:{1:00}:{2:00}.{3:00}", ts.Hours, ts.Minutes, ts.Seconds, ts.Milliseconds / 10); // ϴ(1) label10.Text = elapsedTime; // ϴ(1) PriorityQueue redQ = new PriorityQueue(); // ϴ(1) PriorityQueue greenQ = new PriorityQueue(); // ϴ(1) PriorityQueue blueQ = new PriorityQueue(); // ϴ(1) ImageOperations.getFrequency(ImageMatrix, redQ, greenQ, blueQ); // ϴ(N^2) where n is the largest between width and height Huffman huffmanRed = new Huffman(redQ); // ϴ(n log n) where n is the largest between width and height Huffman huffmanGreen = new Huffman(greenQ); // ϴ(n log n) where n is the largest between width and height Huffman huffmanBlue = new Huffman(blueQ); // ϴ(n log n) where n is the largest between width and height double originalSize = ImageMatrix.GetLength(0) * ImageMatrix.GetLength(1) * 8 * 3; // ϴ(1) double compressedSize = huffmanRed.getCompressedSize() + huffmanGreen.getCompressedSize() + huffmanBlue.getCompressedSize(); // ϴ(1) double compressionRatio = (compressedSize / originalSize) * 100; // ϴ(1) compressRatio.Text = compressionRatio + "%"; // ϴ(1) Compression.compress(ImageMatrix, huffmanRed, huffmanGreen, huffmanBlue, seed, short.Parse(txtGaussSigma.Text)); // ϴ(N^2) where n is the largest between width and height ts = stopWatch.Elapsed; // ϴ(1) // Format and display the TimeSpan value. elapsedTime = String.Format("{0:00}:{1:00}:{2:00}.{3:00}", ts.Hours, ts.Minutes, ts.Seconds, ts.Milliseconds / 10); // ϴ(1) label12.Text = elapsedTime; // ϴ(1) RGBPixel[,] ImageMatrix2 = Compression.decompress("compressEncode.bin"); // ϴ(N^2) where n is the largest between width and height ImageOperations.DisplayImage(ImageMatrix2, pictureBox3); // ϴ(N^2) where n is the largest between width and height ts = stopWatch.Elapsed; // ϴ(1) // Format and display the TimeSpan value. elapsedTime = String.Format("{0:00}:{1:00}:{2:00}.{3:00}", ts.Hours, ts.Minutes, ts.Seconds, ts.Milliseconds / 10); // ϴ(1) label11.Text = elapsedTime; // ϴ(1) stopWatch.Stop(); // ϴ(1) }
/// <summary> /// Get the width of the image /// </summary> /// <param name="ImageMatrix">2D array that contains the image</param> /// <returns>Image Width</returns> public static int GetWidth(RGBPixel[,] ImageMatrix) { try { return(ImageMatrix.GetLength(1)); } catch { MessageBox.Show("please enter the photo"); } return(ImageMatrix.GetLength(1)); }
private void computeFrequencies(RGBPixel[,] arr) { for (int i = 0; i < arr.GetLength(0); i++) { for (int j = 0; j < arr.GetLength(1); j++) { redFrequencies[arr[i, j].red]++; blueFrequencies[arr[i, j].blue]++; greenFrequencies[arr[i, j].green]++; } } }
public static void Gausssmooth(RGBPixel[,] Matrix) { for (int i = 0; i < Matrix.GetLength(0); i++) { for (int j = 0; j < Matrix.GetLength(1); j++) { double ky = 0.5 * (Matrix[i, j].red + Matrix[i, j].green) * (Matrix[i, j].red + Matrix[i, j].green + 1) + Matrix[i, j].green; ky = 0.5 * (Matrix[i, j].blue + ky) * (Matrix[i, j].blue + ky + 1) + ky; Matrix[i, j] = colorDic[ky]; } } }
// change group's coloros to its average color public static void UpdatedMatrix(RGBPixel[, ,] Update, RGBPixel[,] Matrix) { int row = Matrix.GetLength(0); int col = Matrix.GetLength(1); for (int i = 0; i < row; i++) { for (int j = 0; j < col; j++) { Matrix[i, j] = Update[Matrix[i, j].red, Matrix[i, j].blue, Matrix[i, j].green]; } } }
//find distnict colors in image matrix public static void Diffcolors(RGBPixel[,] ImageMatrix) { int length = ImageMatrix.GetLength(0); int width = ImageMatrix.GetLength(1); bool[,,] vis = new bool[257, 257, 257]; for (int i = 0; i < length; i++) { for (int j = 0; j < width; j++) { vis[ImageMatrix[i, j].blue, ImageMatrix[i, j].green, ImageMatrix[i, j].red] = true; } } for (int i = 0; i < 256; i++) { for (int j = 0; j < 256; j++) { for (int k = 0; k < 256; k++) { if (vis[i, j, k]) { colorsNum++; } } } } colors = new RGBPixel[colorsNum]; int count = 0; for (int i = 0; i < 256; i++) { for (int j = 0; j < 256; j++) { for (int k = 0; k < 256; k++) { if (vis[i, j, k]) { var p = new RGBPixel(); p.blue = (byte)i; p.green = (byte)j; p.red = (byte)k; colors[count++] = p; } } } } }
public static YCbCrPixel[,] toYCCMatrix(RGBPixel[,] source) { int rows = source.GetLength(0); int columns = source.GetLength(1); YCbCrPixel[,] result = new YCbCrPixel[rows, columns]; for (int i = 0; i < rows; i++) { for (int j = 0; j < columns; j++) { result[i, j] = source[i, j].ToYCC(); } } return(result); }
public static RGBPixel[,] QuantizedImage(RGBPixel[,] imageMatrix, List <RGBPixel> palette) { int height = imageMatrix.GetLength(0); int width = imageMatrix.GetLength(1); for (int i = 0; i < height; i++) { for (int j = 0; j < width; j++) { imageMatrix[i, j] = calculateWeight(palette, imageMatrix[i, j]); } } return(imageMatrix); }
public object FastEncryptionWithCompression(ref KeyValuePair <string, int> key, ref RGBPixel[,] imageSource, ref long[,] mFrequencies) { int imageHeight = imageSource.GetLength(0), imageWidth = imageSource.GetLength(1); Int64 shiftKey = ConvertToInt(key.Key); int tapPosition = key.Value; // contains the length of {0 and 1} in the key to know the last bit index int lastPosition = key.Key.Length; RGBPixel[,] targetImage = new RGBPixel[imageHeight, imageWidth]; for (int i = 0; i < imageHeight; i++) { for (int j = 0; j < imageWidth; j++) { if (imageSource != null) { byte redValue = imageSource[i, j].Red; byte greenValue = imageSource[i, j].Green; byte blueValue = imageSource[i, j].Blue; // get new shifted key shiftKey = FastShiftKey(shiftKey, lastPosition, tapPosition); // XOR the new value of key with the color values redValue ^= (byte)(shiftKey & 0xff); shiftKey = FastShiftKey(shiftKey, lastPosition, tapPosition); greenValue ^= (byte)(shiftKey & 0xff); shiftKey = FastShiftKey(shiftKey, lastPosition, tapPosition); blueValue ^= (byte)(shiftKey & 0xff); // set the new pixel colors targetImage[i, j] = new RGBPixel(redValue, greenValue, blueValue); if (mFrequencies.GetLength(0) > 1) { mFrequencies[0, redValue]++; mFrequencies[1, greenValue]++; mFrequencies[2, blueValue]++; } } } } return(targetImage); }
public void Find_Distinct_colors(RGBPixel[,] ImageMatrix) { bool[,,] Histogram = new bool[256, 256, 256]; for (int i = 0; i < ImageMatrix.GetLength(0); i++) { for (int j = 0; j < ImageMatrix.GetLength(1); j++) { if (!Histogram[ImageMatrix[i, j].red, ImageMatrix[i, j].green, ImageMatrix[i, j].blue]) { Distinct.Add(ImageMatrix[i, j]); } Histogram[ImageMatrix[i, j].red, ImageMatrix[i, j].green, ImageMatrix[i, j].blue] = true; } } MessageBox.Show(Distinct.Count.ToString()); }
// total function's complexity --> Exact(E + D) --> E = number of edges in cluster , D = number of Distinct colors in this cluster /// <summary> /// replace the color of each pixal in the image matrix array /// with its represented color in the pallete /// </summary> /// <param name="ImageMatrix"></param> /// <param name="pallete"></param> public static void Quntization(RGBPixel[,] ImageMatrix, RGBPixelD[,,] pallete) { int width = ImageMatrix.GetLength(1); // O(1) int height = ImageMatrix.GetLength(0); // O(1) for (int i = 0; i < height; i++) // E(N) --> N = height { for (int j = 0; j < width; j++) // E(N) --> N = width { var index = ImageMatrix[i, j]; // O(1) var col = pallete[index.red, index.blue, index.green]; // O(1) ImageMatrix[i, j].red = (byte)col.red; // O(1) ImageMatrix[i, j].green = (byte)col.green; // O(1) ImageMatrix[i, j].blue = (byte)col.blue; // O(1) } } }//Total_complexity = E(N^2) --> N = width or height
public static int distinctColor(RGBPixel[,] Matrix) { for (int i = 0; i < Matrix.GetLength(0); i++) { for (int j = 0; j < Matrix.GetLength(1); j++) { double ky = 0.5 * (Matrix[i, j].red + Matrix[i, j].green) * (Matrix[i, j].red + Matrix[i, j].green + 1) + Matrix[i, j].green; ky = 0.5 * (Matrix[i, j].blue + ky) * (Matrix[i, j].blue + ky + 1) + ky; if (my_hashtable.ContainsKey(ky) != true) { my_hashtable.Add(ky, 1); distinct.Add(Matrix[i, j]); } } } return(distinct.Count); }
public static int GetDistinctColors(RGBPixel[,] Buffer) { bool[,,] Visited_Buffer = new bool[256, 256, 256]; DistinctColours = new List <RGBPixel>(); for (int i = 0; i < Buffer.GetLength(0); i++) { for (int j = 0; j < Buffer.GetLength(1); j++) { if (Visited_Buffer[Buffer[i, j].red, Buffer[i, j].green, Buffer[i, j].blue] == false) { Visited_Buffer[Buffer[i, j].red, Buffer[i, j].green, Buffer[i, j].blue] = true; DistinctColours.Add(Buffer[i, j]); } } } return(DistinctColours.Count); }
/// <summary> /// Display the given image on the given PictureBox object /// </summary> /// <param name="ImageMatrix">2D array that contains the image</param> /// <param name="PicBox">PictureBox object to display the image on it</param> public static void DisplayImage(RGBPixel[,] ImageMatrix, PictureBox PicBox) { // Create Image: //============== int Height = ImageMatrix.GetLength(0); int Width = ImageMatrix.GetLength(1); Bitmap ImageBMP = new Bitmap(Width, Height, PixelFormat.Format32bppArgb); for (int i = 0; i < Height; i++) { for (int j = 0; j < Width; j++) { Color Pixel = Color.FromArgb(ImageMatrix[i, j].red, ImageMatrix[i, j].green, ImageMatrix[i, j].blue); ImageBMP.SetPixel(j, i, Pixel); } } PicBox.Image = ImageBMP; }
public void QuantizeImage(List <RGBPixel> palette, RGBPixel[,] ImageMatrix) { Quantized_Image = new RGBPixel[ImageMatrix.GetLength(0), ImageMatrix.GetLength(1)]; Updated_Colours = new RGBPixel[256, 256, 256]; for (int i = 0; i < NewColors.Count; i++) { int groupSize = NewColors[i].Count; for (int j = 0; j < groupSize; j++) { Updated_Colours[ImageUtilities.DistinctColours[NewColors[i][j]].red, ImageUtilities.DistinctColours[NewColors[i][j]].blue, ImageUtilities.DistinctColours[NewColors[i][j]].green] = Palette[i]; } } for (int i = 0; i < ImageMatrix.GetLength(0); i++) { for (int j = 0; j < ImageMatrix.GetLength(1); j++) { Quantized_Image[i, j] = Updated_Colours[ImageMatrix[i, j].red, ImageMatrix[i, j].blue, ImageMatrix[i, j].green]; } } }
}//Clustring public static RGBPixel[,] Refill_Mtrx(RGBPixel[,] M)//refill the matrix again to get it back to image { int h = M.GetLength(0), w = M.GetLength(1), d1, d2; //get width and height of matrix for (int i = 0; i < h; i++) //height { for (int j = 0; j < w; j++) //width { /*shift this cell to know its cluster*/ d1 = M[i, j].red << 8 | M[i, j].green; d2 = d1 << 8 | M[i, j].blue; byte[] b = BitConverter.GetBytes(nodes[Node_Cluster[d2]]);//split this cluster average into red and green and blue //regive this value with its cluster average M[i, j].red = b[2]; M[i, j].green = b[1]; M[i, j].blue = b[0]; } } return(M);// return this matrix }
/// <summary> /// Get the width of the image /// </summary> /// <param name="ImageMatrix">2D array that contains the image</param> /// <returns>Image Width</returns> public static int GetWidth(RGBPixel[,] ImageMatrix) { try { return(ImageMatrix.GetLength(1)); } catch { MessageBox.Show("No Image were added."); return(0); } }
// build the graph public void build(RGBPixel [,] image) { int r = image.GetLength(0); int c = image.GetLength(1); for (int i = 0; i < r; i++) { for (int j = 0; j < c; j++) { Vector2D w = ImageOperations.CalculatePixelEnergies(j, i, image); // energy (right , bellow) if (i + 1 < r) // down child { add_edge(j, i, j, i + 1, w.Y); } if (j + 1 < c) // right child { add_edge(j, i, j + 1, i, w.X); } } } }
public void ChangeMatrixColor(Hashtable FinalColor) { for (int i = 0; i < ImageMatrix.GetLength(0); i++) { for (int j = 0; j < ImageMatrix.GetLength(1); j++) { String key; //O(1) String C1 = ImageMatrix[i, j].red.ToString(); //O(1) if (C1.Length == 1) { C1 = "00" + C1; } //O(1) if (C1.Length == 2) { C1 = "0" + C1; } //O(1) String C2 = ImageMatrix[i, j].blue.ToString(); //O(1) if (C2.Length == 1) { C2 = "00" + C2; } //O(1) if (C2.Length == 2) { C2 = "0" + C2; } //O(1) String C3 = ImageMatrix[i, j].green.ToString(); //O(1) if (C3.Length == 1) { C3 = "00" + C3; } //O(1) if (C3.Length == 2) { C3 = "0" + C3; } //O(1) key = C1 + C2 + C3; ImageMatrix[i, j] = (RGBPixel)FinalColor[key]; //O(1) } } }