Re: help me in c# - C# Discussion Boards

Luc Pattyn16-May-12 4:04

16-May-12 4:04

While text (strings) may be a good way to transfer information between systems, it is not the recommended way to store data in memory. So my approach would be slightly different, I'd have:
- a textual representation of the data, as an example X123Y456E would be a point with X and Y coordinates (E stands for a terminator, think newline character);
- a class that holds an instance of data, in the example:

public class MyPoint {
    public int X;
    public int Y;
}

BTW: I prefer a class over a struct to avoid all kinds of problems including boxing/unboxing.
- some container that holds all the data, this could be List<MyPoint> myCollectionOfPoints in the example.
- a method to receive textual data, convert it on the spot, and store it; it might look like:

public void ReceiveMyPoint() {
    string line=mySerialPort.ReadLine(); // this is why newline is a good terminator!
    ... here comes input validation and parsing, resulting in actual values:
    int x=...;
    int y=...;
    myCollectionOfPoints.Add(new MyPoint(x,y));
}

- a thread to consume all incoming data, basically a loop calling ReceiveMyPoint() all the time. I don't use the DataReceived event here, as that does not synchronize with incoming text lines, it fires randomly when "some data" is available, which may well be a partial line of text.

The net result is your interface is textual, the data is in meaningful types (two ints in the example), conversion is not a separate step, and no storage space gets wasted.

Note: you must program defensively when receiving data from another system, as it will go wrong sooner or later, with a bad conenction, some missing characters, a noisy line, whatever. Therefore validation is important; even the simplest checksum or CRC added to each message would prove valuable.

Smile | :)

Luc Pattyn [My Articles] Nil Volentibus Arduum

Re: Array of Strings....

glennPattonWork316-May-12 4:18

glennPattonWork3

16-May-12 4:18

Great thanks for that, can you recommend a reference for this type of data handling (or really any data handling would be useful) It's just I am tasked with writing an application to interface to a board that does exist (yet!) "it will do it like the X board, you already written the software for that". I'm looking at this as a chance to increase my Windows knowledge!

Glenn

Re: Array of Strings....

Luc Pattyn16-May-12 4:31

Luc Pattyn

16-May-12 4:31

Sorry, no reference, just my own experience with peripherals and embedded systems.

Smile | :)

Luc Pattyn [My Articles] Nil Volentibus Arduum

Re: Array of Strings....

glennPattonWork316-May-12 4:34

glennPattonWork3

16-May-12 4:34

Ah well google & MSDN, I did look at something on the code project that confused me! (link earlier)

Glenn

Re: Array of Strings....

glennPattonWork316-May-12 6:08

glennPattonWork3

16-May-12 6:08

Thanks for the Help! I now have it getting the data tomorrow I can work on it further,but now have the bones.

Glenn

help me in c#

ri198716-May-12 0:13

ri1987

16-May-12 0:13

/* SIFT.cs
 * The SIFT algorithm class
 * where all the algorithm specific methods
 * are implemented 
 */
using System;
using System.Collections.Generic;
using System.Text;
using System.Drawing;
using System.Collections;
using System.Windows.Forms;
class SIFT
{   static double initDev = 1.6;                                        // initial standard deviation variable
    static public int OctavesCount = 2;                                 // Octaves count for pyramid
    static public int scalesPerOctave = 4;                              // scales(blurred images) count per octave
    static double minDoG = 0.01;                                        // minimal threshold of keypoint value
    static public double norm;                                          // normalization factor for kp coordinates
    static double edgeRatio = 10;                                       // minimal edge ratio for kp localization
    public static double[][,] BuildGaussianBlurPyramid(Bitmap image)    // method to build the Gaussian pyramid with bitmap input
    {   int ind=1;                                                      // index variable to help for image indexing in pyramid
        int imgCount = scalesPerOctave * OctavesCount;                  // calculate total image count 
        double deviation = initDev;                                     // local initial deviation variable
        double[][,] imgMatrix=new double[imgCount][,];                  // array to store values of each image matrix in the pyramid 
        imgMatrix[0]=new double[image.Width,image.Height];              // image matrix initial dimension  
        imgMatrix[0]=ImageProcessing.BitmapToGrayscaleMatrix(image);    // create grayscale image matrix from bitmap coloured image
        for (int i = 0; i < OctavesCount; i++){             
         for (int j = 1; j < scalesPerOctave; j++){                     // Build Gaussian blur with given image mtrx and deviation 
          imgMatrix[ind]=ImageProcessing.GaussianBlurBWMat(imgMatrix[ind-1], deviation);
          deviation *= 2;                                               // double the previous deviation
          ind++;                                                        // increment current image index
                                                   }
          if (ind<imgCount-1)                                           // check for current image index and build next octave
          imgMatrix[ind] = ImageProcessing.SubSample(imgMatrix[ind-2]); // down-sample the image by factor of 2 for the next octave 
          deviation /= 3.2;                                             // divide the deviation to start from twice the initial
          ind++;                                                        // increment the current image index
              
                                               }
        return imgMatrix;                                               // return the resulting image matrix pyramid array
      }                                                                 // method to build the DoG pyramid
      public static double[][,] BuildDoGPyramid(double[][,] gaussianPyr) 
      {   int ind = 0;                                                  // index value for controlling the image indxes 
          double[][,] resDoG = new double[(scalesPerOctave - 1) * OctavesCount][,];
          for (int i = 0; i < gaussianPyr.GetLength(0) - 1; i += 1){
              if ((i + 1) % (scalesPerOctave) == 0){                    // go to next octave
                 continue;
                                                   }                    // calculate the DoG matrix
              resDoG[ind] = ImageProcessing.CalculateDoGMatrix(gaussianPyr[i], gaussianPyr[i + 1]);
              ind++;                                                    // increment the current image index
          }

          return resDoG;                                                // return resulting DoG matrix pyramid
      }
      public static ArrayList FindKeypoints(double[][,] imgMatrixPyr)   // method to find keypoints
      {   ArrayList KpL = new ArrayList();                              // create arraylist to store keypoints
          double[][][,] imgMatrix = new double[2][][,];                 // create array to store three level pyr img matrix
          norm = 3.0 / (initDev * 2);                                   // calculate the normalization factor
          int DoGCount = (scalesPerOctave - 1) * OctavesCount;          // count the total number of DoG images 
          imgMatrix[0] = new double[3][,];                              // array to store first octave image matrix
          imgMatrix[1] = new double[3][,];                              // array to store second octave image matrix
          int pyrL = 0;                                                 // layer index 
          int pyrIm = 0;                                                // image index in layer
          for (int i = 0; i < DoGCount; i++){                            
              if (i == 3){
                  pyrL++;                                               // increment layer index
                  pyrIm = 0;                                            // assign zero to image index to start next dimension 
                         } 
              imgMatrix[pyrL][pyrIm] = imgMatrixPyr[i];                 // copy DoG pyr. image matrix from 1 dim array to 2 dim.
              pyrIm++;                                                  // increment image index
                                            }
          int min = 1, max = 1;                                         // min and max initialization
          for (int l = 0; l < imgMatrix.GetLength(0); l++){
           for (int y = 1; y < imgMatrix[l][1].GetLength(1) - 1; y++)
            for (int x = 1; x < imgMatrix[l][1].GetLength(0) - 1; x++){
             double point = imgMatrix[l][1][x, y];                      // pick one point of the central DoG image matrix
             if (Math.Abs(point) <= minDoG)                             // check for the keypoint threshold
             continue;
             for (int i = 0; i < imgMatrix[l].GetLength(0); i++){
                                                                        // check the point for maximum 
             if (max == 1 & imgMatrix[l][i][x - 1, y - 1] < point & imgMatrix[l][i][x - 1, y] < point & 
             imgMatrix[l][i][x, y - 1] < point & imgMatrix[l][i][x, y] <= point & imgMatrix[l][i][x + 1, y + 1] < point & 
             imgMatrix[l][i][x + 1, y] < point & imgMatrix[l][i][x, y + 1] < point & imgMatrix[l][i][x - 1, y + 1] < point & 
             imgMatrix[l][i][x + 1, y - 1] < point){
             max = 1;
                                                   }
             else max = 0;     
                                                                        // check the point for minimum
             if (min == 1 & imgMatrix[l][i][x - 1, y - 1] > point & imgMatrix[l][i][x - 1, y] > point & 
             imgMatrix[l][i][x, y - 1] > point & imgMatrix[l][i][x, y] >= point & imgMatrix[l][i][x + 1, y + 1] > point & 
             imgMatrix[l][i][x + 1, y] > point & imgMatrix[l][i][x, y + 1] > point & imgMatrix[l][i][x - 1, y + 1] > point & 
             imgMatrix[l][i][x + 1, y - 1] > point){
             min = 1;                              }
             else min = 0;
                                                   }
             if (max == 1 || min == 1){                                 // check if the point is max or min
                Keypoint kp = new Keypoint();                           // create keypoint object to 
                kp.x = x;                                               // assign x coordinate of extreme point
                kp.y = y;                                               // assign y coordinate of extreme point
                kp.value = point;                                       // assign extreme point value
                kp.layer = l;                                           // assign layer of extreme point
                KpL.Add(kp);          }                                 // add keypoint to arraylist
             min = 1; max = 1;                                          // reinitialize min and max values  
           }
          }
          return KpL;                                                   // return keypoint list
      }
                                                                        // method to localize keypoints for the given edge ratio
    public static ArrayList KeypointLocalization(ArrayList initKpList, double[][,] DoGMatrix, int edgeRatio)
    {   Keypoint initKp;                                                // Keypoint object to store initial keypoints
        ArrayList retKp = new ArrayList();                              // create Arraylist to store refined keypoints 
        double Dxx, Dyy, Dxy, Trace, Det;                               // variables to store elements, trace and Det. of Hessian
        double r = ((edgeRatio + 1) * (edgeRatio + 1)) / 2;             // calculate the threshold from the edgratio
        for (int i = 0; i < initKpList.Count; i++){
          initKp = (Keypoint)initKpList[i];                             // cast the value from Arraylist object to the Keypoint
          int l = initKp.layer == 0 ? 1 : 4;                            // identify the current layer
          if (initKp.x <= 0 || initKp.y <= 0 ||                         // drop keypoints which are on the borders
              initKp.x >= DoGMatrix[l].GetLength(0) - 1 
              || initKp.y >= DoGMatrix[l].GetLength(0) - 1)
          continue;
          Dxx = DoGMatrix[l][initKp.x + 1, initKp.y]                    // calculate the x,x derivative by pixel differences
          + DoGMatrix[l][initKp.x - 1, initKp.y] 
          - 2.0 * DoGMatrix[l][initKp.x, initKp.y];
          Dyy = DoGMatrix[l][initKp.x, initKp.y + 1]                    //calculate the y,y derivative by pixel differences
          + DoGMatrix[l][initKp.x, initKp.y - 1] 
          - 2.0 * DoGMatrix[l][initKp.x, initKp.y];
          Dxy = 0.25 * ((DoGMatrix[l][initKp.x + 1, initKp.y + 1]       // calculate the x,y derivative by pixel differences
          - DoGMatrix[l][initKp.x + 1, initKp.y - 1]) -
          (DoGMatrix[l][initKp.x - 1, initKp.y + 1] 
          - DoGMatrix[l][initKp.x - 1, initKp.y - 1]));
          Trace = Dxx + Dyy;                                            // calculate the trace of Hessian
          Det = Dxx * Dyy - (Dxy * Dxy);                                // calculate the determinant of Hessian
          if ((Trace * Trace) / Det > r)                                // drop the keypoints which contradict the given ratio
          continue;
          else
          retKp.Add(initKp);                                            // add the remaining keypoints
                                                  }
       return retKp;                                                    // return the resulting Arraylist with localized keypoints
      }
                                                                        // method for orientation assignment
      public static ArrayList AssignOrientations(ArrayList finKpList, double[][,] blurredMatrix)
      {   Keypoint finKp;                                               // keypoint variable to store localized keyoints
          ArrayList orKp=new ArrayList();                               // create arraylist to store keypoints with orientations 
          double binVal = 2 * Math.PI / 36;                             // calculate the angle value of one histogram bin
          for (int i = 0; i < finKpList.Count; i++){                  
           finKp = (Keypoint)finKpList[i];                              // cast from array list object to keypoint object
           finKp.scale = initDev*(finKp.layer + 1);                     // caclulate the keypoint scale
           double[] histBin = new double[36];                           // create the double array as a colour histogram
           int kpReg=(int)(1.5*finKp.scale/2+0.5);                      // calculate the radius of the region around the keypoint 
           double SigmaFact=2*2.25*finKp.scale*finKp.scale;             // caclutate the sigma factor for gaussian weight
           int layer=finKp.layer==0?1:5;                                // identify the current keypoint layer
           int regXSt=finKp.x-kpReg<1?1:finKp.x-kpReg;                  // calculate the x coordinate of the region start and end 
           int regXEnd = finKp.x + kpReg > blurredMatrix[layer].GetLength(0) ? blurredMatrix[layer].GetLength(0) : finKp.x + kpReg;
           int regYSt = finKp.y - kpReg < 1 ? 1 : finKp.y - kpReg;      // calculate the x coordinate of the region start and end 
           int regYEnd = finKp.y + kpReg > blurredMatrix[layer].GetLength(1) ? blurredMatrix[layer].GetLength(1) : finKp.y + kpReg;
           for (int y=regYSt; y<regYEnd; y++)
            for (int x=regXSt; x<regXEnd; x++){                         // calculate the gaussian wight 
             double gaussianWight = Math.Exp(-(Math.Pow(x - finKp.x, 2) + Math.Pow(y - finKp.y, 2) / SigmaFact));
                                                                        // calculate the portion of the direction angle in histogram
             double portInHist = (CalMagnitudeAndDirection(x,y, blurredMatrix[layer]).direction + Math.PI) / (2 * Math.PI);
                                                                        // identify the bin index for current keypoint direction 
             int ind = (int)(portInHist * 36 == 36 ? 0 : portInHist * 36); 
                                                                        // add magnitude weightened by gaussian to the respective bin
             histBin[ind]+=CalMagnitudeAndDirection(x,y,blurredMatrix[layer]).magnitude*gaussianWight;
                                              }
            double max = 0.0;                                           // initialize the maximal bin value
            int maxBin = 0;                                             // initialize the maximal bin index
            for (int bi = 0; bi < histBin.GetLength(0); ++bi){
             if (histBin[bi] > max){                                    // check if the next bin is bigger
              max = histBin[bi];                                        // store new bin as the maximal
              maxBin = bi;         }                                    // mark the new bin index as the index of the maximal bin  
                                                              }
            max = maxBin * binVal - Math.PI;                            // change angle range from [0, 2PI] to [-PI,PI]
            max=max<-Math.PI?2*Math.PI+max:max;                         // check if angle is outside [-PI,PI]
            max = max > Math.PI ? max - 2 * Math.PI : max;              // check if angle is outside [-PI,PI]
            finKp.orientation = max;                                    // assign maximal bin direction as keypoint orientation
            orKp.Add(finKp);                                            // add keypoint with assign orientation
                                                    }
          return orKp;                                                  // return keypoint list of keypoints with their orientations
        }
                                                                        // method to calculate keypoint magnitude and direction
        static KpOrientPar CalMagnitudeAndDirection(int x, int y, double[,] blurredMatrix)
        {   KpOrientPar kpO=new KpOrientPar();                          // create orientation object for magnitude and direction pair
                                                                        // calculate the keypoint magnitude by pixel differences
            kpO.magnitude = Math.Sqrt (Math.Pow (blurredMatrix[x + 1, y] - blurredMatrix[x - 1, y], 2.0) +
			Math.Pow (blurredMatrix[x, y + 1] -	blurredMatrix[x, y - 1], 2.0));
                                                                        // calculate the keypoint direction by pixel differences 
            kpO.direction = Math.Atan2(blurredMatrix[x, y + 1] - blurredMatrix[x, y - 1],
			blurredMatrix[x + 1, y] - blurredMatrix[x - 1, y]);
            return kpO;                                                 // return orientation object with magnitude and direction
        }
        public static ArrayList CreateDescriptor(ArrayList finKpList, double[][,] blurredMatrix)
        {   int kpReg = 16;                                             // region size around the keypoint
            Keypoint finKp;                                             // keypoint object to store input keypoint
            ArrayList descKp=new ArrayList();                           // arraylist keypoint to store descriptor assigned keypoints 
            double SigmaFact = 2*(kpReg / 2) * (kpReg / 2);             // calculate the sigma factor for gaussian weight
            for (int kpi = 0; kpi < finKpList.Count; kpi++){    
             finKp = (Keypoint)finKpList[kpi];                          // cast from arraylist object to keypoint object
             int regXSt = finKp.x - kpReg < 1 ? 1 : finKp.x - kpReg;    // calculate x coordinate of keypoint region start
             int regYSt = finKp.y - kpReg < 1 ? 1 : finKp.y - kpReg;    // calculate y coordinate of keypoint region start
             int regXEnd = regXSt + 4;                                  // calculate x coordinate of keypoint region end
             int regYEnd = regXSt + 4;                                  // calculate y coordinate of keypoint region end
             double[,][] desc = new double[4, 4][];                     // create double array to store descriptor
             for (int jj = 0; jj < 4; jj++)
              for (int ii = 0; ii < 4; ii++ )
               desc[ii,jj] = new double[8];                             // initialize double array of descriptor
               int layer = finKp.layer == 0 ? 1 : 5;
               for (int i = 0; i <= 3; i++)
                for (int j =0 ; j <= 3; j++)
                 for (int xi = regXSt; xi < regXEnd; xi++)
                  for (int yi = regYSt; yi < regYEnd; yi++){            // calculate current value of x and y coordinates
                   int x =xi+j*4 >= blurredMatrix[layer].GetLength(0)-1 ? blurredMatrix[layer].GetLength(0)-2 : xi+j*4;
                   int y = yi+i*4 >= blurredMatrix[layer].GetLength(1)-1 ? blurredMatrix[layer].GetLength(1)-2 : yi+i*4;
                   double yRot = Math.Sin(-finKp.orientation) * (x - finKp.x) +
                   Math.Cos(-finKp.orientation) * (y - finKp.y);        // rotate x coordinate by keypoint orientation value
                   double xRot = Math.Cos(-finKp.orientation) * (x - finKp.x) -
                   Math.Sin(-finKp.orientation) * (y - finKp.y);        // rotate y coordinate by keypoint orientation value
                                                                        // calculate gaussian weight 
                   double gaussianWight = Math.Exp(-(Math.Pow(xRot, 2) + Math.Pow(yRot, 2) / SigmaFact));
                                                                        // calculate direction and rotate by keypoint orientation
                   double direction = CalMagnitudeAndDirection(x, y, blurredMatrix[layer]).direction - finKp.orientation;
                   if (direction < 0)                                   // check if direction degree is out of [0,2PI] range
                    direction += 2.0 * Math.PI;
                   else if (direction > 2.0 * Math.PI)
                         direction -= 2.0 * Math.PI;
                   double portInHist = direction / (2 * Math.PI);       // calculate the protion of the direction in the histogram
                                                                        // idetify the index of orientation bin
                   int ind = (int)(portInHist * 8 == 8 ? 0 : portInHist * 8);
                                                                        // add magn. weighted by gaussian to the resp.direction bin
                   desc[i, j][ind] += CalMagnitudeAndDirection(x, y, blurredMatrix[layer]).magnitude * gaussianWight;
                                                          }
                finKp.descriptor=desc;                                  // assign descriptor to keypoint object
                descKp.Add(finKp);                                      // add keypoint to the resulting arraylist object
            }
            return descKp;                                              // return arraylist of keypoints with descriptors
        }
}
class KpOrientPar                                                       // helper class to store magnitude and direction
{
    public double magnitude;                                            // double variable to store keypoint magnitude
    public double direction;                                            // double variable to store keypoint direction
}

Re: help me in c#

ri198716-May-12 0:14

ri1987

16-May-12 0:14

help me to debug this program ..thanx alot

Re: help me in c#

Killzone DeathMan16-May-12 0:27

Killzone DeathMan

16-May-12 0:27

You want to know what this code do?

Re: help me in c#

Pete O'Hanlon16-May-12 0:27

Pete O'Hanlon

16-May-12 0:27

In the code that calls the method you are getting an exception in, put a breakpoint on the line that calls the method (you can do this by pressing F9). Run your program in debug mode and when the program hits the breakpoint, it will pause execution. At this point, press F11 to step into the method. Check that the parameters that you have passed in are what you would expect. Now, use the step over command (F10) to step over individual code lines, and use step into (F11) to inspect methods that are of interest to you.

Check the values of variables as you progress to determine where the calculation goes wrong (if that's what your problem is), and to check that the right value gets allocated to the right place. This is going to require a lot of patience on your part, so take your time. It also means that you are going to have to be aware of what values you should get at what point.

And that, in a nutshell, is how you debug it.

*pre-emptive celebratory nipple tassle jiggle* - Sean Ewington

"Mind bleach! Send me mind bleach!" - Nagy Vilmos

CodeStash - Online Snippet Management | My blog | MoXAML PowerToys | Mole 2010 - debugging made easier

Re: help me in c#

ri198716-May-12 0:57

ri1987

16-May-12 0:57

Sorry for the inconvenience
please try the program and debug the error then paste it here
thanx

Re: help me in c#

Dave Kreskowiak16-May-12 1:38

Dave Kreskowiak

16-May-12 1:38

That's not going to happen. YOU have to debug the program. We're telling you how to do that. It's up to YOU to do the work. We're not getting paid to do your job, YOU are.

A guide to posting questions on CodeProject[^]

Dave Kreskowiak

Re: help me in c#

Pete O'Hanlon16-May-12 1:43

Pete O'Hanlon

16-May-12 1:43

I wish I'd realised that I never had to debug a program again, I could just post the code here and someone would do it for me. How exciting.

*pre-emptive celebratory nipple tassle jiggle* - Sean Ewington

"Mind bleach! Send me mind bleach!" - Nagy Vilmos

CodeStash - Online Snippet Management | My blog | MoXAML PowerToys | Mole 2010 - debugging made easier

Re: help me in c#

Dave Kreskowiak16-May-12 7:59

Dave Kreskowiak

16-May-12 7:59

And it's FREE!! Why the Hell haven't we done this before!?

A guide to posting questions on CodeProject[^]

Dave Kreskowiak

Re: help me in c#

Pete O'Hanlon16-May-12 1:41

Pete O'Hanlon

16-May-12 1:41

Did you know that if you put a scarf on a snowball, it stands a really good chance of surving in hades? Your chances of me debugging and working out what the problem is with your code is absolutely nil. Unless you're happy to pay my rates, which I have to warn you are very expensive.

*pre-emptive celebratory nipple tassle jiggle* - Sean Ewington

"Mind bleach! Send me mind bleach!" - Nagy Vilmos

CodeStash - Online Snippet Management | My blog | MoXAML PowerToys | Mole 2010 - debugging made easier

help me

ri198715-May-12 23:35

ri1987

15-May-12 23:35

i have a multi programs in c# that does not execute plz help me,,,i want to know the error in this programs
first:
/* SIFT.cs
* The SIFT algorithm class
* where all the algorithm specific methods
* are implemented
*/
using System;
using System.Collections.Generic;
using System.Text;
using System.Drawing;
using System.Collections;
using System.Windows.Forms;
class SIFT
{ static double initDev = 1.6; // initial standard deviation variable
static public int OctavesCount = 2; // Octaves count for pyramid
static public int scalesPerOctave = 4; // scales(blurred images) count per octave
static double minDoG = 0.01; // minimal threshold of keypoint value
static public double norm; // normalization factor for kp coordinates
static double edgeRatio = 10; // minimal edge ratio for kp localization
public static double[][,] BuildGaussianBlurPyramid(Bitmap image) // method to build the Gaussian pyramid with bitmap input
{ int ind=1; // index variable to help for image indexing in pyramid
int imgCount = scalesPerOctave * OctavesCount; // calculate total image count
double deviation = initDev; // local initial deviation variable
double[][,] imgMatrix=new double[imgCount][,]; // array to store values of each image matrix in the pyramid
imgMatrix[0]=new double[image.Width,image.Height]; // image matrix initial dimension
imgMatrix[0]=ImageProcessing.BitmapToGrayscaleMatrix(image); // create grayscale image matrix from bitmap coloured image
for (int i = 0; i < OctavesCount; i++){
for (int j = 1; j < scalesPerOctave; j++){ // Build Gaussian blur with given image mtrx and deviation
imgMatrix[ind]=ImageProcessing.GaussianBlurBWMat(imgMatrix[ind-1], deviation);
deviation *= 2; // double the previous deviation
ind++; // increment current image index
}
if (ind<imgcount-1) check="" for="" current="" image="" index="" and="" build="" next="" octave
="" imgmatrix[ind]="ImageProcessing.SubSample(imgMatrix[ind-2]);" down-sample="" the="" by="" factor="" of="" 2="" octave=""
="" deviation="" =="" 3.2;="" divide="" to="" start="" from="" twice="" initial
="" ind++;="" increment="" index
="" }
="" return="" imgmatrix;="" resulting="" matrix="" pyramid="" array
="" }="" method="" dog="" pyramid
="" public="" static="" double[][,]="" builddogpyramid(double[][,]="" gaussianpyr)="" {="" int="" ind="0;" value="" controlling="" indxes="" resdog="new" double[(scalesperoctave="" -="" 1)="" *="" octavescount][,];
="" (int="" i="0;" <="" gaussianpyr.getlength(0)="" 1;="" +="1){
" if="" ((i="" %="" (scalesperoctave)="=" 0){="" go="" continue;
="" calculate="" matrix
="" resdog[ind]="ImageProcessing.CalculateDoGMatrix(gaussianPyr[i]," gaussianpyr[i="" 1]);
="" }

="" resdog;="" arraylist="" findkeypoints(double[][,]="" imgmatrixpyr)="" find="" keypoints
="" kpl="new" arraylist();="" create="" store="" double[][][,]="" imgmatrix="new" double[2][][,];="" array="" three="" level="" pyr="" img="" norm="3.0" (initdev="" 2);="" normalization="" factor
="" dogcount="(scalesPerOctave" octavescount;="" count="" total="" number="" images="" imgmatrix[0]="new" double[3][,];="" first="" imgmatrix[1]="new" second="" pyrl="0;" layer="" pyrim="0;" in="" layer
="" dogcount;="" i++){="" (i="=" 3){
="" pyrl++;="" assign="" zero="" dimension="" imgmatrix[pyrl][pyrim]="imgMatrixPyr[i];" copy="" pyr.="" 1="" dim="" dim.
="" pyrim++;="" min="1," max="1;" initialization
="" l="0;" imgmatrix.getlength(0);="" l++){
="" y="1;" imgmatrix[l][1].getlength(1)="" y++)
="" x="1;" imgmatrix[l][1].getlength(0)="" x++){
="" double="" point="imgMatrix[l][1][x," y];="" pick="" one="" central="" (math.abs(point)="" keypoint="" threshold
="" imgmatrix[l].getlength(0);="" i++){
="" maximum="" (max="=" &="" imgmatrix[l][i][x="" 1,="" 1]="" y]="" imgmatrix[l][i][x,="" point){
="" else="" minimum
="" (min="="> point & imgMatrix[l][i][x - 1, y] > point &
imgMatrix[l][i][x, y - 1] > point & imgMatrix[l][i][x, y] >= point & imgMatrix[l][i][x + 1, y + 1] > point &
imgMatrix[l][i][x + 1, y] > point & imgMatrix[l][i][x, y + 1] > point & imgMatrix[l][i][x - 1, y + 1] > point &
imgMatrix[l][i][x + 1, y - 1] > point){
min = 1; }
else min = 0;
}
if (max == 1 || min == 1){ // check if the point is max or min
Keypoint kp = new Keypoint(); // create keypoint object to
kp.x = x; // assign x coordinate of extreme point
kp.y = y; // assign y coordinate of extreme point
kp.value = point; // assign extreme point value
kp.layer = l; // assign layer of extreme point
KpL.Add(kp); } // add keypoint to arraylist
min = 1; max = 1; // reinitialize min and max values
}
}
return KpL; // return keypoint list
}
// method to localize keypoints for the given edge ratio
public static ArrayList KeypointLocalization(ArrayList initKpList, double[][,] DoGMatrix, int edgeRatio)
{ Keypoint initKp; // Keypoint object to store initial keypoints
ArrayList retKp = new ArrayList(); // create Arraylist to store refined keypoints
double Dxx, Dyy, Dxy, Trace, Det; // variables to store elements, trace and Det. of Hessian
double r = ((edgeRatio + 1) * (edgeRatio + 1)) / 2; // calculate the threshold from the edgratio
for (int i = 0; i < initKpList.Count; i++){
initKp = (Keypoint)initKpList[i]; // cast the value from Arraylist object to the Keypoint
int l = initKp.layer == 0 ? 1 : 4; // identify the current layer
if (initKp.x <= 0 || initKp.y <= 0 || // drop keypoints which are on the borders
initKp.x >= DoGMatrix[l].GetLength(0) - 1
|| initKp.y >= DoGMatrix[l].GetLength(0) - 1)
continue;
Dxx = DoGMatrix[l][initKp.x + 1, initKp.y] // calculate the x,x derivative by pixel differences
+ DoGMatrix[l][initKp.x - 1, initKp.y]
- 2.0 * DoGMatrix[l][initKp.x, initKp.y];
Dyy = DoGMatrix[l][initKp.x, initKp.y + 1] //calculate the y,y derivative by pixel differences
+ DoGMatrix[l][initKp.x, initKp.y - 1]
- 2.0 * DoGMatrix[l][initKp.x, initKp.y];
Dxy = 0.25 * ((DoGMatrix[l][initKp.x + 1, initKp.y + 1] // calculate the x,y derivative by pixel differences
- DoGMatrix[l][initKp.x + 1, initKp.y - 1]) -
(DoGMatrix[l][initKp.x - 1, initKp.y + 1]
- DoGMatrix[l][initKp.x - 1, initKp.y - 1]));
Trace = Dxx + Dyy; // calculate the trace of Hessian
Det = Dxx * Dyy - (Dxy * Dxy); // calculate the determinant of Hessian
if ((Trace * Trace) / Det > r) // drop the keypoints which contradict the given ratio
continue;
else
retKp.Add(initKp); // add the remaining keypoints
}
return retKp; // return the resulting Arraylist with localized keypoints
}
// method for orientation assignment
public static ArrayList AssignOrientations(ArrayList finKpList, double[][,] blurredMatrix)
{ Keypoint finKp; // keypoint variable to store localized keyoints
ArrayList orKp=new ArrayList(); // create arraylist to store keypoints with orientations
double binVal = 2 * Math.PI / 36; // calculate the angle value of one histogram bin
for (int i = 0; i < finKpList.Count; i++){
finKp = (Keypoint)finKpList[i]; // cast from array list object to keypoint object
finKp.scale = initDev*(finKp.layer + 1); // caclulate the keypoint scale
double[] histBin = new double[36]; // create the double array as a colour histogram
int kpReg=(int)(1.5*finKp.scale/2+0.5); // calculate the radius of the region around the keypoint
double SigmaFact=2*2.25*finKp.scale*finKp.scale; // caclutate the sigma factor for gaussian weight
int layer=finKp.layer==0?1:5; // identify the current keypoint layer
int regXSt=finKp.x-kpReg<1?1:finKp.x-kpReg; // calculate the x coordinate of the region start and end
int regXEnd = finKp.x + kpReg > blurredMatrix[layer].GetLength(0) ? blurredMatrix[layer].GetLength(0) : finKp.x + kpReg;
int regYSt = finKp.y - kpReg < 1 ? 1 : finKp.y - kpReg; // calculate the x coordinate of the region start and end
int regYEnd = finKp.y + kpReg > blurredMatrix[layer].GetLength(1) ? blurredMatrix[layer].GetLength(1) : finKp.y + kpReg;
for (int y=regYSt; y<regyend; y++)
="" for="" (int="" x="regXSt;" x<regxend;="" x++){="" calculate="" the="" gaussian="" wight=""
="" double="" gaussianwight="Math.Exp(-(Math.Pow(x" -="" finkp.x,="" 2)="" +="" math.pow(y="" finkp.y,="" sigmafact));
="" portion="" of="" direction="" angle="" in="" histogram
="" portinhist="(CalMagnitudeAndDirection(x,y," blurredmatrix[layer]).direction="" math.pi)="" (2="" *="" math.pi);
="" identify="" bin="" index="" current="" keypoint="" int="" ind="(int)(portInHist" 36="=" ?="" 0="" :="" 36);="" add="" magnitude="" weightened="" by="" to="" respective="" bin
="" histbin[ind]+="CalMagnitudeAndDirection(x,y,blurredMatrix[layer]).magnitude*gaussianWight;
" }
="" max="0.0;" initialize="" maximal="" value
="" maxbin="0;" index
="" bi="0;" <="" histbin.getlength(0);="" ++bi){
="" if="" (histbin[bi]=""> max){ // check if the next bin is bigger
max = histBin[bi]; // store new bin as the maximal
maxBin = bi; } // mark the new bin index as the index of the maximal bin
}
max = maxBin * binVal - Math.PI; // change angle range from [0, 2PI] to [-PI,PI]
max=max<-Math.PI?2*Math.PI+max:max; // check if angle is outside [-PI,PI]
max = max > Math.PI ? max - 2 * Math.PI : max; // check if angle is outside [-PI,PI]
finKp.orientation = max; // assign maximal bin direction as keypoint orientation
orKp.Add(finKp); // add keypoint with assign orientation
}
return orKp; // return keypoint list of keypoints with their orientations
}
// method to calculate keypoint magnitude and direction
static KpOrientPar CalMagnitudeAndDirection(int x, int y, double[,] blurredMatrix)
{ KpOrientPar kpO=new KpOrientPar(); // create orientation object for magnitude and direction pair
// calculate the keypoint magnitude by pixel differences
kpO.magnitude = Math.Sqrt (Math.Pow (blurredMatrix[x + 1, y] - blurredMatrix[x - 1, y], 2.0) +
Math.Pow (blurredMatrix[x, y + 1] - blurredMatrix[x, y - 1], 2.0));
// calculate the keypoint direction by pixel differences
kpO.direction = Math.Atan2(blurredMatrix[x, y + 1] - blurredMatrix[x, y - 1],
blurredMatrix[x + 1, y] - blurredMatrix[x - 1, y]);
return kpO; // return orientation object with magnitude and direction
}
public static ArrayList CreateDescriptor(ArrayList finKpList, double[][,] blurredMatrix)
{ int kpReg = 16; // region size around the keypoint
Keypoint finKp; // keypoint object to store input keypoint
ArrayList descKp=new ArrayList(); // arraylist keypoint to store descriptor assigned keypoints
double SigmaFact = 2*(kpReg / 2) * (kpReg / 2); // calculate the sigma factor for gaussian weight
for (int kpi = 0; kpi < finKpList.Count; kpi++){
finKp = (Keypoint)finKpList[kpi]; // cast from arraylist object to keypoint object
int regXSt = finKp.x - kpReg < 1 ? 1 : finKp.x - kpReg; // calculate x coordinate of keypoint region start
int regYSt = finKp.y - kpReg < 1 ? 1 : finKp.y - kpReg; // calculate y coordinate of keypoint region start
int regXEnd = regXSt + 4; // calculate x coordinate of keypoint region end
int regYEnd = regXSt + 4; // calculate y coordinate of keypoint region end
double[,][] desc = new double[4, 4][]; // create double array to store descriptor
for (int jj = 0; jj < 4; jj++)
for (int ii = 0; ii < 4; ii++ )
desc[ii,jj] = new double[8]; // initialize double array of descriptor
int layer = finKp.layer == 0 ? 1 : 5;
for (int i = 0; i <= 3; i++)
for (int j =0 ; j <= 3; j++)
for (int xi = regXSt; xi < regXEnd; xi++)
for (int yi = regYSt; yi < regYEnd; yi++){ // calculate current value of x and y coordinates
int x =xi+j*4 >= blurredMatrix[layer].GetLength(0)-1 ? blurredMatrix[layer].GetLength(0)-2 : xi+j*4;
int y = yi+i*4 >= blurredMatrix[layer].GetLength(1)-1 ? blurredMatrix[layer].GetLength(1)-2 : yi+i*4;
double yRot = Math.Sin(-finKp.orientation) * (x - finKp.x) +
Math.Cos(-finKp.orientation) * (y - finKp.y); // rotate x coordinate by keypoint orientation value
double xRot = Math.Cos(-finKp.orientation) * (x - finKp.x) -
Math.Sin(-finKp.orientation) * (y - finKp.y); // rotate y coordinate by keypoint orientation value
// calculate gaussian weight
double gaussianWight = Math.Exp(-(Math.Pow(xRot, 2) + Math.Pow(yRot, 2) / SigmaFact));
// calculate direction and rotate by keypoint orientation
double direction = CalMagnitudeAndDirection(x, y, blurredMatrix[layer]).direction - finKp.orientation;
if (direction < 0) // check if direction degree is out of [0,2PI] range
direction += 2.0 * Math.PI;
else if (direction > 2.0 * Math.PI)
direction -= 2.0 * Math.PI;
double portInHist = direction / (2 * Math.PI); // calculate the protion of the direction in the histogram
// idetify the index of orientation bin
int ind = (int)(portInHist * 8 == 8 ? 0 : portInHist * 8);
// add magn. weighted by gaussian to the resp.direction bin
desc[i, j][ind] += CalMagnitudeAndDirection(x, y, blurredMatrix[layer]).magnitude * gaussianWight;
}
finKp.descriptor=desc; // assign descriptor to keypoint object
descKp.Add(finKp); // add keypoint to the resulting arraylist object
}
return descKp; // return arraylist of keypoints with descriptors
}
}
class KpOrientPar // helper class to store magnitude and direction
{
public double magnitude; // double variable to store keypoint magnitude
public double direction; // double variable to store keypoint direction
}

Re: help me

Pete O'Hanlon15-May-12 23:47

Pete O'Hanlon

15-May-12 23:47

First, when you put code into a forum message, please use the code button and choose the appropriate language. What you do is highlight the code you've inserted, click code and then choose C# from the drop down that appears. As it stands, we cannot even read your code.

Second, what do you mean by "it does not execute"? Do you mean you get compilation errors? Does the program start and then immediately stop? Does it have logic errors?

It's highly unlikely that anyone is going to take your code, drop it into a program and debug it for you. Now's the time for you to learn valuable debugging skills. Set breakpoints. Inspect variables, step through code and do all the other things that you will be expected to do as a professional coder.

*pre-emptive celebratory nipple tassle jiggle* - Sean Ewington

"Mind bleach! Send me mind bleach!" - Nagy Vilmos

CodeStash - Online Snippet Management | My blog | MoXAML PowerToys | Mole 2010 - debugging made easier

Re: help me

ri198716-May-12 0:07

ri1987

16-May-12 0:07

ok i will do it now

Re: help me

ri198716-May-12 0:09

ri1987

16-May-12 0:09

sorry ,but how to use the code button i didn't know from it

Re: help me

Killzone DeathMan16-May-12 0:23

Killzone DeathMan

16-May-12 0:23

There is a button that says 'code'...

defines

columbos1492715-May-12 22:42

columbos14927

15-May-12 22:42

Hello,
How can i create C like defines in C#.
What i did so far is:
1.I created class called Global

class Global
    {
        public const Int32 D_PARAMETER = 5;
        public const Int32 NODE_SIZE = 2*D_PARAMETER;
        public const Int32 NULL = -1;
    }

2.When i want to use some of the const from the class i have to use it like this:
root.Parent = Global.NULL;

3.What can i do so i can only use

NULL

and not

Global.NULL

?

Thanks.

Re: defines

Pete O'Hanlon15-May-12 22:52

Pete O'Hanlon

15-May-12 22:52

You can't. When you think about it, you'll see why - everything in C# is object-oriented, so there has to be some ability to work with an object, whereas C does not have this restriction.

*pre-emptive celebratory nipple tassle jiggle* - Sean Ewington

"Mind bleach! Send me mind bleach!" - Nagy Vilmos

CodeStash - Online Snippet Management | My blog | MoXAML PowerToys | Mole 2010 - debugging made easier

Re: defines

Andy41115-May-12 23:29

Andy411

15-May-12 23:29

Well, think about your design. For me it looks like you want to port C code directly to C# without taking care of the designe (classes, objects, etc)

Anyway you can solve it this way:

static sealed class ConstContainer
{
   public static readonly int FOO = 1;
}

And use it that way.

dummy.MyProperty = ConstContainer.FOO;

Re: defines

PIEBALDconsult16-May-12 3:29

PIEBALDconsult

16-May-12 3:29

You can't, and that's one way in which C# improves on C/C++.

What happens in C/C++ when you include two different header files for two things you want to use that both define NULL, but define different values for it? It doesn't work. So more modern languages use namespaces and such so you can qualify a name when there's a collission.

See also this recent thread and see if there's anything you find helpfull: http://www.codeproject.com/Messages/4235173/Re-include-a-file.aspx[^]

Update database SQL via C#

jojoba201115-May-12 22:32

jojoba2011

15-May-12 22:32

The story is :
the customers have previous application and database (full with their specific data). Now a new version is ready and the customer gets the update. In the mean time we made some modification on DB (new table, columns, maybe an old column deleted, or whatever). I’m pretty new in Linq and also SQL databases and my first solution can be: I check the applications/databases version and implement all the changes step by step comparing all tables, columns, keys, constrains, etc. (all this new information I have in my dbml and the old I asked from the existing DB). And I’ll do this each time the version changed. But somehow I feel, this is NOT a smart solution so I look for a general solution of this problem.

Re: Update database SQL via C#

Pete O'Hanlon15-May-12 23:21

Pete O'Hanlon

15-May-12 23:21

A simple forum question is not the right place to answer this. What you are talking about is release management, and is a huge topic in its own right. You have so much to take into account, whether it's a desktop app or ASP.NET, and so on.

I'd suggest that you start with this[^] document.

*pre-emptive celebratory nipple tassle jiggle* - Sean Ewington

"Mind bleach! Send me mind bleach!" - Nagy Vilmos

CodeStash - Online Snippet Management | My blog | MoXAML PowerToys | Mole 2010 - debugging made easier

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.