FOR /R %%f IN (_svn) DO IF EXIST "%%f" (
ATTRIB -h "%%f"
RENAME "%%f" .svn
ATTRIB +h "%%f"
)

 "C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\bin\dumpbin.exe" /imports c:\windows\explorer.exe > explorer.imports.txt

    api-ms-win-core-datetime-l1-1-1.dll
             14015E848 Import Address Table
             1401613E0 Import Name Table
                     0 time date stamp
                     0 Index of first forwarder reference

                           2 GetDateFormatW
                           1 GetDateFormatEx
                           4 GetTimeFormatEx

 public class SendEmailsTask : ScheduledTaskTemplate

using System;

namespace DNTScheduler.TestWebApplication.WebTasks
{
    public class SendEmailsTask : ScheduledTaskTemplate
    {
        /// <summary>
        /// اگر چند جاب در یک زمان مشخص داشتید، این خاصیت ترتیب اجرای آن‌ها را مشخص خواهد کرد
        /// </summary>
        public override int Order
        {
            get { return 1; }
        }

        public override bool RunAt(DateTime utcNow)
        {
            if (this.IsShuttingDown || this.Pause)
                return false;

            var now = utcNow.AddHours(3.5);
            return now.Minute % 2 == 0 && now.Second == 1;
        }

        public override void Run()
        {
            if (this.IsShuttingDown || this.Pause)
                return;

            System.Diagnostics.Trace.WriteLine("Running Send Emails");
        }

        public override string Name
        {
            get { return "ارسال ایمیل"; }
        }
    }
}

        public override bool RunAt(DateTime utcNow)
        {
            if (this.IsShuttingDown || this.Pause)
                return false;

            var now = utcNow.AddHours(3.5);
            return now.Hour == 23 && now.Minute == 33 && now.Second == 1;
        }

using System;
using System.Net;

namespace DNTScheduler.TestWebApplication.WebTasks
{
    public static class ScheduledTasksRegistry
    {
        public static void Init()
        {
            ScheduledTasksCoordinator.Current.AddScheduledTasks(
                new SendEmailsTask(),
                new DoBackupTask());

            ScheduledTasksCoordinator.Current.OnUnexpectedException = (exception, scheduledTask) =>
            {
                //todo: log the exception.
                System.Diagnostics.Trace.WriteLine(scheduledTask.Name + ":" + exception.Message);
            };

            ScheduledTasksCoordinator.Current.Start();
        }

        public static void End()
        {
            ScheduledTasksCoordinator.Current.Dispose();
        }

        public static void WakeUp(string pageUrl)
        {
            try
            {
                using (var client = new WebClient())
                {
                    client.Credentials = CredentialCache.DefaultNetworkCredentials;
                    client.Headers.Add("User-Agent", "ScheduledTasks 1.0");
                    client.DownloadData(pageUrl);
                }
            }
            catch (Exception ex)
            {
                //todo: log ex
                System.Diagnostics.Trace.WriteLine(ex.Message);
            }
        }
    }
}

using System;
using System.Configuration;
using DNTScheduler.TestWebApplication.WebTasks;

namespace DNTScheduler.TestWebApplication
{
    public class Global : System.Web.HttpApplication
    {
        protected void Application_Start(object sender, EventArgs e)
        {
            ScheduledTasksRegistry.Init();
        }

        protected void Application_End()
        {
            ScheduledTasksRegistry.End();
            //نکته مهم این روش نیاز به سرویس پینگ سایت برای زنده نگه داشتن آن است
            ScheduledTasksRegistry.WakeUp(ConfigurationManager.AppSettings["SiteRootUrl"]);
        }
    }
}

<?xml version="1.0"?><configuration><appSettings><add key="SiteRootUrl" value="http://localhost:10189/Default.aspx" /></appSettings></configuration>

var jobsList = ScheduledTasksCoordinator.Current.ScheduledTasks.Select(x => new
{
   TaskName = x.Name,
   LastRunTime = x.LastRun,
   LastRunWasSuccessful = x.IsLastRunSuccessful,
   IsPaused = x.Pause,
}).ToList();

using (var src = new Mat(@"..\..\Images\cvmorph.Png", LoadMode.AnyDepth | LoadMode.AnyColor))
using (var dst = new Mat())
{    src.CopyTo(dst);    var elementShape = StructuringElementShape.Rect;    var maxIterations = 10;     var erodeDilateWindow = new Window("Erode/Dilate", image: dst);    var erodeDilateTrackbar = erodeDilateWindow.CreateTrackbar(        name: "Iterations", value: 0, max: maxIterations * 2 + 1,        callback: pos =>        {            var n = pos - maxIterations;            var an = n > 0 ? n : -n;            var element = Cv2.GetStructuringElement(                    elementShape,                    new Size(an * 2 + 1, an * 2 + 1),                    new Point(an, an));            if (n < 0)            {                Cv2.Erode(src, dst, element);            }            else            {                Cv2.Dilate(src, dst, element);            }            Cv2.PutText(dst, (n < 0) ?                string.Format("Erode[{0}]", elementShape) :                string.Format("Dilate[{0}]", elementShape),                new Point(10, 15), FontFace.HersheyPlain, 1, Scalar.Black);            erodeDilateWindow.Image = dst;        });      Cv2.WaitKey();     erodeDilateWindow.Dispose();
}

  using (var src = new Mat(@"..\..\Images\cvmorph.Png", LoadMode.AnyDepth | LoadMode.AnyColor))    using (var dst = new Mat())    {        src.CopyTo(dst);        var elementShape = StructuringElementShape.Rect;        var maxIterations = 10;        var openCloseWindow = new Window("Open/Close", image: dst);        var openCloseTrackbar = openCloseWindow.CreateTrackbar(            name: "Iterations", value: 0, max: maxIterations * 2 + 1,            callback: pos =>            {                var n = pos - maxIterations;                var an = n > 0 ? n : -n;                var element = Cv2.GetStructuringElement(                        elementShape,                        new Size(an * 2 + 1, an * 2 + 1),                        new Point(an, an));                if (n < 0)                {                    Cv2.MorphologyEx(src, dst, MorphologyOperation.Open, element);                }                else                {                    Cv2.MorphologyEx(src, dst, MorphologyOperation.Close, element);                }                Cv2.PutText(dst, (n < 0) ?                    string.Format("Open/Erosion followed by Dilation[{0}]", elementShape)                    : string.Format("Close/Dilation followed by Erosion[{0}]", elementShape),                    new Point(10, 15), FontFace.HersheyPlain, 1, Scalar.Black);                openCloseWindow.Image = dst;            });         Cv2.WaitKey();          openCloseWindow.Dispose();    }

private static void rotateImage(double angle, double scale, Mat src, Mat dst)
{    var imageCenter = new Point2f(src.Cols / 2f, src.Rows / 2f);    var rotationMat = Cv2.GetRotationMatrix2D(imageCenter, angle, scale);    Cv2.WarpAffine(src, dst, rotationMat, src.Size());
}

using OpenCvSharp;
using OpenCvSharp.CPlusPlus;
namespace OpenCVSharpSample09
{    class Program    {        static void Main(string[] args)        {            using (var src = new Mat(@"..\..\Images\Penguin.Png", LoadMode.AnyDepth | LoadMode.AnyColor))            using (var dst = new Mat())            {                src.CopyTo(dst);                using (var window = new Window("Resize/Rotate/Blur",                                                image: dst, flags: WindowMode.AutoSize))                {                    var angle = 0.0;                    var scale = 0.7;                    var angleTrackbar = window.CreateTrackbar(                        name: "Angle", value: 0, max: 180,                        callback: pos =>                        {                            angle = pos;                            rotateImage(angle, scale, src, dst);                            window.Image = dst;                        });                    var scaleTrackbar = window.CreateTrackbar(                        name: "Scale", value: 1, max: 10,                        callback: pos =>                        {                            scale = pos / 10f;                            rotateImage(angle, scale, src, dst);                            window.Image = dst;                        });                     angleTrackbar.Callback.DynamicInvoke(0);                    scaleTrackbar.Callback.DynamicInvoke(1);                    Cv2.WaitKey();                }            }        }        private static void rotateImage(double angle, double scale, Mat src, Mat dst)        {            var imageCenter = new Point2f(src.Cols / 2f, src.Rows / 2f);            var rotationMat = Cv2.GetRotationMatrix2D(imageCenter, angle, scale);            Cv2.WarpAffine(src, dst, rotationMat, src.Size());        }    }
}

var resizeTrackbar = window.CreateTrackbar(    name: "Resize", value: 1, max: 100,    callback: pos =>    {        Cv2.Resize(src, dst,            new Size(src.Width + pos, src.Height + pos),            interpolation: Interpolation.Cubic);        window.Image = dst;    });

var resizeTrackbar = window.CreateTrackbar(    name: "Resize", value: 1, max: 100,    callback: pos =>    {        rotateImage(angle, scale, src, dst);        Cv2.Resize(dst, dst,            new Size(src.Width + pos, src.Height + pos),            interpolation: Interpolation.Cubic);        window.Image = dst;    });

var blurTrackbar = window.CreateTrackbar(   name: "Blur", value: 1, max: 100,   callback: pos =>   {       if (pos % 2 == 0) pos++;       rotateImage(angle, scale, src, dst);       Cv2.GaussianBlur(dst, dst, new Size(pos, pos), sigmaX: 0);       window.Image = dst;   });

private static void updateBrightnessContrast(Mat src, Mat modifiedSrc, int brightness, int contrast)
{    brightness = brightness - 100;    contrast = contrast - 100;    double alpha, beta;    if (contrast > 0)    {        double delta = 127f * contrast / 100f;        alpha = 255f / (255f - delta * 2);        beta = alpha * (brightness - delta);    }    else    {        double delta = -128f * contrast / 100;        alpha = (256f - delta * 2) / 255f;        beta = alpha * brightness + delta;    }    src.ConvertTo(modifiedSrc, MatType.CV_8UC3, alpha, beta);
}

using (var src = new Mat(@"..\..\Images\Penguin.Png", LoadMode.AnyDepth | LoadMode.AnyColor))
{    using (var sourceWindow = new Window("Source", image: src,           flags: WindowMode.AutoSize | WindowMode.FreeRatio))    {        using (var histogramWindow = new Window("Histogram",               flags: WindowMode.AutoSize | WindowMode.FreeRatio))        {            var brightness = 100;            var contrast = 100;            var brightnessTrackbar = sourceWindow.CreateTrackbar(                    name: "Brightness", value: brightness, max: 200,                    callback: pos =>                    {                        brightness = pos;                        updateImageCalculateHistogram(sourceWindow, histogramWindow, src, brightness, contrast);                    });            var contrastTrackbar = sourceWindow.CreateTrackbar(                name: "Contrast", value: contrast, max: 200,                callback: pos =>                {                    contrast = pos;                    updateImageCalculateHistogram(sourceWindow, histogramWindow, src, brightness, contrast);                });            brightnessTrackbar.Callback.DynamicInvoke(brightness);            contrastTrackbar.Callback.DynamicInvoke(contrast);            Cv2.WaitKey();        }    }
}

private static void calculateHistogram1(Window histogramWindow, Mat src, Mat modifiedSrc)
{    const int histogramSize = 64;    int[] dimensions = { histogramSize }; // Histogram size for each dimension    Rangef[] ranges = { new Rangef(0, histogramSize) }; // min/max    using (var histogram = new Mat())    {        Cv2.CalcHist(            images: new[] { modifiedSrc },            channels: new[] { 0 },            mask: null,            hist: histogram,            dims: 1,            histSize: dimensions,            ranges: ranges);        using (var histogramImage = (Mat)(Mat.Ones(rows: src.Rows, cols: src.Cols, type: MatType.CV_8U) * 255))        {            // Scales and draws histogram            Cv2.Normalize(histogram, histogram, 0, histogramImage.Rows, NormType.MinMax);            var binW = Cv.Round((double)histogramImage.Cols / histogramSize);            var color = Scalar.All(100);            for (var i = 0; i < histogramSize; i++)            {                Cv2.Rectangle(histogramImage,                    new Point(i * binW, histogramImage.Rows),                    new Point((i + 1) * binW, histogramImage.Rows - Cv.Round(histogram.Get<float>(i))),                    color,                    -1);            }            histogramWindow.Image = histogramImage;        }    }
}

var src = new Mat(@"..\..\Images\fruits.jpg", LoadMode.AnyDepth | LoadMode.AnyColor);
Cv2.ImShow("Source", src);
Cv2.WaitKey(1); // do events
Cv2.Blur(src, src, new Size(15, 15));
Cv2.ImShow("Blurred Image", src);
Cv2.WaitKey(1); // do events
// Converts the MxNx3 image into a Kx3 matrix where K=MxN and
// each row is now a vector in the 3-D space of RGB.
// change to a Mx3 column vector (M is number of pixels in image)
var columnVector = src.Reshape(cn: 3, rows: src.Rows * src.Cols);
// convert to floating point, it is a requirement of the k-means method of OpenCV.
var samples = new Mat();
columnVector.ConvertTo(samples, MatType.CV_32FC3);
for (var clustersCount = 2; clustersCount <= 8; clustersCount += 2)
{    var bestLabels = new Mat();    var centers = new Mat();    Cv2.Kmeans(        data: samples,        k: clustersCount,        bestLabels: bestLabels,        criteria:            new TermCriteria(type: CriteriaType.Epsilon | CriteriaType.Iteration, maxCount: 10, epsilon: 1.0),        attempts: 3,        flags: KMeansFlag.PpCenters,        centers: centers);    var clusteredImage = new Mat(src.Rows, src.Cols, src.Type());    for (var size = 0; size < src.Cols * src.Rows; size++)    {        var clusterIndex = bestLabels.At<int>(0, size);        var newPixel = new Vec3b        {            Item0 = (byte)(centers.At<float>(clusterIndex, 0)), // B            Item1 = (byte)(centers.At<float>(clusterIndex, 1)), // G            Item2 = (byte)(centers.At<float>(clusterIndex, 2)) // R        };        clusteredImage.Set(size / src.Cols, size % src.Cols, newPixel);    }    Cv2.ImShow(string.Format("Clustered Image [k:{0}]", clustersCount), clusteredImage);    Cv2.WaitKey(1); // do events
}
Cv2.WaitKey();
Cv2.DestroyAllWindows();

var src = new Mat(@"..\..\Images\corridor.jpg", LoadMode.AnyDepth | LoadMode.AnyColor);
var srcCopy = new Mat();
src.CopyTo(srcCopy);
var markerMask = new Mat();
Cv2.CvtColor(srcCopy, markerMask, ColorConversion.BgrToGray);
var imgGray = new Mat();
Cv2.CvtColor(markerMask, imgGray, ColorConversion.GrayToBgr);
markerMask = new Mat(markerMask.Size(), markerMask.Type(), s: Scalar.All(0));
var sourceWindow = new Window("Source (Select areas by mouse and then press space)")
{    Image = srcCopy
};
var previousPoint = new Point(-1, -1);
sourceWindow.OnMouseCallback += (@event, x, y, flags) =>
{    if (x < 0 || x >= srcCopy.Cols || y < 0 || y >= srcCopy.Rows)    {        return;    }    if (@event == MouseEvent.LButtonUp || !flags.HasFlag(MouseEvent.FlagLButton))    {        previousPoint = new Point(-1, -1);    }    else if (@event == MouseEvent.LButtonDown)    {        previousPoint = new Point(x, y);    }    else if (@event == MouseEvent.MouseMove && flags.HasFlag(MouseEvent.FlagLButton))    {        var pt = new Point(x, y);        if (previousPoint.X < 0)        {            previousPoint = pt;        }        Cv2.Line(img: markerMask, pt1: previousPoint, pt2: pt, color: Scalar.All(255), thickness: 5);        Cv2.Line(img: srcCopy, pt1: previousPoint, pt2: pt, color: Scalar.All(255), thickness: 5);        previousPoint = pt;        sourceWindow.Image = srcCopy;    }
};

Point[][] contours; //vector<vector<Point>> contours;
HiearchyIndex[] hierarchyIndexes; //vector<Vec4i> hierarchy;
Cv2.FindContours(    markerMask,    out contours,    out hierarchyIndexes,    mode: ContourRetrieval.CComp,    method: ContourChain.ApproxSimple);

var markers = new Mat(markerMask.Size(), MatType.CV_32S, s: Scalar.All(0));
var componentCount = 0;
var contourIndex = 0;
while ((contourIndex >= 0))
{    Cv2.DrawContours(        markers,        contours,        contourIndex,        color: Scalar.All(componentCount + 1),        thickness: -1,        lineType: LineType.Link8,        hierarchy: hierarchyIndexes,        maxLevel: int.MaxValue);    componentCount++;    contourIndex = hierarchyIndexes[contourIndex].Next;
}

var rnd = new Random();
var colorTable = new List<Vec3b>();
for (var i = 0; i < componentCount; i++)
{    var b = rnd.Next(0, 255); //Cv2.TheRNG().Uniform(0, 255);    var g = rnd.Next(0, 255); //Cv2.TheRNG().Uniform(0, 255);    var r = rnd.Next(0, 255); //Cv2.TheRNG().Uniform(0, 255);    colorTable.Add(new Vec3b((byte)b, (byte)g, (byte)r));
}
Cv2.Watershed(src, markers);
var watershedImage = new Mat(markers.Size(), MatType.CV_8UC3);
// paint the watershed image
for (var i = 0; i < markers.Rows; i++)
{    for (var j = 0; j < markers.Cols; j++)    {        var idx = markers.At<int>(i, j);        if (idx == -1)        {            watershedImage.Set(i, j, new Vec3b(255, 255, 255));        }        else if (idx <= 0 || idx > componentCount)        {            watershedImage.Set(i, j, new Vec3b(0, 0, 0));        }        else        {            watershedImage.Set(i, j, colorTable[idx - 1]);        }    }
}
watershedImage = watershedImage * 0.5 + imgGray * 0.5;
Cv2.ImShow("Watershed Transform", watershedImage);
Cv2.WaitKey(1); //do events

var img1 = new Mat(@"..\..\Images\left.png", LoadMode.GrayScale);
Cv2.ImShow("Left", img1);
Cv2.WaitKey(1); // do events
var img2 = new Mat(@"..\..\Images\right.png", LoadMode.GrayScale);
Cv2.ImShow("Right", img2);
Cv2.WaitKey(1); // do events
// detecting keypoints
// FastFeatureDetector, StarDetector, SIFT, SURF, ORB, BRISK, MSER, GFTTDetector, DenseFeatureDetector, SimpleBlobDetector
// SURF = Speeded Up Robust Features
var detector = new SURF(hessianThreshold: 400); //SurfFeatureDetector
var keypoints1 = detector.Detect(img1);
var keypoints2 = detector.Detect(img2);
// computing descriptors, BRIEF, FREAK
// BRIEF = Binary Robust Independent Elementary Features
var extractor = new BriefDescriptorExtractor();
var descriptors1 = new Mat();
var descriptors2 = new Mat();
extractor.Compute(img1, ref keypoints1, descriptors1);
extractor.Compute(img2, ref keypoints2, descriptors2);
// matching descriptors
var matcher = new BFMatcher();
var matches = matcher.Match(descriptors1, descriptors2);
// drawing the results
var imgMatches = new Mat();
Cv2.DrawMatches(img1, keypoints1, img2, keypoints2, matches, imgMatches);
Cv2.ImShow("Matches", imgMatches);
Cv2.WaitKey(1); // do events
Cv2.WaitKey(0);
Cv2.DestroyAllWindows();
img1.Dispose();
img2.Dispose();

var srcImage = new Mat(@"..\..\Images\cvlbl.png");
Cv2.ImShow("Source", srcImage);
Cv2.WaitKey(1); // do events
var binaryImage = new Mat(srcImage.Size(), MatType.CV_8UC1);
Cv2.CvtColor(srcImage, binaryImage, ColorConversion.BgrToGray);

Cv2.Threshold(binaryImage, binaryImage, thresh: 100, maxval: 255, type: ThresholdType.Binary);

 
var detectorParams = new SimpleBlobDetector.Params
{    //MinDistBetweenBlobs = 10, // 10 pixels between blobs    //MinRepeatability = 1,    //MinThreshold = 100,    //MaxThreshold = 255,    //ThresholdStep = 5,    FilterByArea = false,    //FilterByArea = true,    //MinArea = 0.001f, // 10 pixels squared    //MaxArea = 500,    FilterByCircularity = false,    //FilterByCircularity = true,    //MinCircularity = 0.001f,    FilterByConvexity = false,    //FilterByConvexity = true,    //MinConvexity = 0.001f,    //MaxConvexity = 10,    FilterByInertia = false,    //FilterByInertia = true,    //MinInertiaRatio = 0.001f,    FilterByColor = false    //FilterByColor = true,    //BlobColor = 255 // to extract light blobs
};
var simpleBlobDetector = new SimpleBlobDetector(detectorParams);
var keyPoints = simpleBlobDetector.Detect(binaryImage);
Console.WriteLine("keyPoints: {0}", keyPoints.Length);
foreach (var keyPoint in keyPoints)
{    Console.WriteLine("X: {0}, Y: {1}", keyPoint.Pt.X, keyPoint.Pt.Y);
}
var imageWithKeyPoints = new Mat();
Cv2.DrawKeypoints(        image: binaryImage,        keypoints: keyPoints,        outImage: imageWithKeyPoints,        color: Scalar.FromRgb(255, 0, 0),        flags: DrawMatchesFlags.DrawRichKeypoints);
Cv2.ImShow("Key Points", imageWithKeyPoints);
Cv2.WaitKey(1); // do events
Cv2.WaitKey(0);
Cv2.DestroyAllWindows();
srcImage.Dispose();
imageWithKeyPoints.Dispose();

 if src(x,y) > thresh
    dst(x,y) = maxValue
else
    dst(x,y) = 0

var srcImage = new Mat(@"..\..\Images\Test.jpg");
Cv2.ImShow("Source", srcImage);
Cv2.WaitKey(1); // do events
var grayImage = new Mat();
Cv2.CvtColor(srcImage, grayImage, ColorConversion.BgrToGray);
Cv2.EqualizeHist(grayImage, grayImage);

var cascade = new CascadeClassifier(@"..\..\Data\haarcascade_frontalface_alt.xml");
var nestedCascade = new CascadeClassifier(@"..\..\Data\haarcascade_eye_tree_eyeglasses.xml");
var faces = cascade.DetectMultiScale(    image: grayImage,    scaleFactor: 1.1,    minNeighbors: 2,    flags: HaarDetectionType.Zero | HaarDetectionType.ScaleImage,    minSize: new Size(30, 30)    );
Console.WriteLine("Detected faces: {0}", faces.Length);

var rnd = new Random();
var count = 1;
foreach (var faceRect in faces)
{    var detectedFaceImage = new Mat(srcImage, faceRect);    Cv2.ImShow(string.Format("Face {0}", count), detectedFaceImage);    Cv2.WaitKey(1); // do events    var color = Scalar.FromRgb(rnd.Next(0, 255), rnd.Next(0, 255), rnd.Next(0, 255));    Cv2.Rectangle(srcImage, faceRect, color, 3);    count++;
}
Cv2.ImShow("Haar Detection", srcImage);
Cv2.WaitKey(1); // do events

var rnd = new Random();
var count = 1;
foreach (var faceRect in faces)
{    var detectedFaceImage = new Mat(srcImage, faceRect);    Cv2.ImShow(string.Format("Face {0}", count), detectedFaceImage);    Cv2.WaitKey(1); // do events    var color = Scalar.FromRgb(rnd.Next(0, 255), rnd.Next(0, 255), rnd.Next(0, 255));    Cv2.Rectangle(srcImage, faceRect, color, 3);    var detectedFaceGrayImage = new Mat();    Cv2.CvtColor(detectedFaceImage, detectedFaceGrayImage, ColorConversion.BgrToGray);    var nestedObjects = nestedCascade.DetectMultiScale(        image: detectedFaceGrayImage,        scaleFactor: 1.1,        minNeighbors: 2,        flags: HaarDetectionType.Zero | HaarDetectionType.ScaleImage,        minSize: new Size(30, 30)        );    Console.WriteLine("Nested Objects[{0}]: {1}", count, nestedObjects.Length);    foreach (var nestedObject in nestedObjects)    {        var center = new Point        {            X = Cv.Round(nestedObject.X + nestedObject.Width * 0.5) + faceRect.Left,            Y = Cv.Round(nestedObject.Y + nestedObject.Height * 0.5) + faceRect.Top        };        var radius = Cv.Round((nestedObject.Width + nestedObject.Height) * 0.25);        Cv2.Circle(srcImage, center, radius, color, thickness: 3);    }    count++;
}
Cv2.ImShow("Haar Detection", srcImage);
Cv2.WaitKey(1); // do events

 pos/pos-177.pgm 1 0 0 100 40

 neg/neg-274.pgm

private static void createCarImagesFile()
{    var sb = new StringBuilder();    foreach (var file in new DirectoryInfo(@"..\..\CarData\CarData\TrainImages").GetFiles("*pos-*.pgm"))    {        sb.AppendFormat("{0} {1} {2} {3} {4} {5}{6}", file.FullName, 1, 0, 0, 100, 40, Environment.NewLine);    }    File.WriteAllText(@"..\..\CarsInfo\carImages.txt", sb.ToString());
}
private static void createNegativeImagesFile()
{    var sb = new StringBuilder();    foreach (var file in new DirectoryInfo(@"..\..\CarData\CarData\TrainImages").GetFiles("*neg-*.pgm"))    {        sb.AppendFormat("{0}{1}", file.FullName,Environment.NewLine);    }    File.WriteAllText(@"..\..\CarsInfo\negativeImages.txt", sb.ToString());
}

 opencv_createsamples.exe -info carImages.txt -num 550 -w 48 -h 24 -vec cars.vec

 Info file name: carImages.txt
Img file name: (NULL)
Vec file name: cars.vec
BG  file name: (NULL)
Num: 550
BG color: 0
BG threshold: 80
Invert: FALSE
Max intensity deviation: 40
Max x angle: 1.1
Max y angle: 1.1
Max z angle: 0.5
Show samples: FALSE
Original image will be scaled to:
  Width: $backgroundWidth / 48
  Height: $backgroundHeight / 24
Create training samples from images collection...
Done. Created 550 samples

 "c:\opencv\build\x86\vc12\bin\opencv_createsamples.exe" -vec cars.vec -w 48 -h 24

 "E:\opencv\bin\opencv_traincascade.exe" -data data -vec cars.vec -bg negativeImages.txt -numPos 500 -numNeg 500 -numStages 2 -w 48 -h 24 -featureType LBP

public class ImageInfo
{    public Mat Image { set; get; }    public int ImageGroupId { set; get; }    public int ImageId { set; get; }
}

var images = new List<ImageInfo>();
var imageId = 0;
foreach (var dir in new DirectoryInfo(@"..\..\Images").GetDirectories())
{    var groupId = int.Parse(dir.Name.Replace("s", string.Empty)) - 1;    foreach (var imageFile in dir.GetFiles("*.pgm"))    {        images.Add(new ImageInfo        {            Image = new Mat(imageFile.FullName, LoadMode.GrayScale),            ImageId = imageId++,            ImageGroupId = groupId        });    }
}

var model = FaceRecognizer.CreateFisherFaceRecognizer();
model.Train(images.Select(x => x.Image), images.Select(x => x.ImageGroupId));
var rnd = new Random();
var randomImageId = rnd.Next(0, images.Count - 1);
var testSample = images[randomImageId];
Console.WriteLine("Actual group: {0}", testSample.ImageGroupId);
Cv2.ImShow("actual", testSample.Image);
var predictedGroupId = model.Predict(testSample.Image);
Console.WriteLine("Predicted group: {0}", predictedGroupId);

public class ImageInfo
{    public Mat Image { set; get; }    public int ImageGroupId { set; get; }    public int ImageId { set; get; }
}

public IList<ImageInfo> ReadTrainingImages(string path, string ext)
{    var images = new List<ImageInfo>();    var imageId = 1;    foreach (var dir in new DirectoryInfo(path).GetDirectories())    {        var groupId = int.Parse(dir.Name);        foreach (var imageFile in dir.GetFiles(ext))        {            var image = processTrainingImage(new Mat(imageFile.FullName, LoadMode.GrayScale));            if (image == null)            {                continue;            }            images.Add(new ImageInfo            {                Image = image,                ImageId = imageId++,                ImageGroupId = groupId            });        }    }    return images;
}

private static Mat processTrainingImage(Mat gray)
{    var threshImage = new Mat();    Cv2.Threshold(gray, threshImage, Thresh, ThresholdMaxVal, ThresholdType.BinaryInv); // Threshold to find contour    Point[][] contours;    HiearchyIndex[] hierarchyIndexes;    Cv2.FindContours(        threshImage,        out contours,        out hierarchyIndexes,        mode: ContourRetrieval.CComp,        method: ContourChain.ApproxSimple);    if (contours.Length == 0)    {        return null;    }    Mat result = null;    var contourIndex = 0;    while ((contourIndex >= 0))    {        var contour = contours[contourIndex];        var boundingRect = Cv2.BoundingRect(contour); //Find bounding rect for each contour        var roi = new Mat(threshImage, boundingRect); //Crop the image        //Cv2.ImShow("src", gray);        //Cv2.ImShow("roi", roi);        //Cv.WaitKey(0);        var resizedImage = new Mat();        var resizedImageFloat = new Mat();        Cv2.Resize(roi, resizedImage, new Size(10, 10)); //resize to 10X10        resizedImage.ConvertTo(resizedImageFloat, MatType.CV_32FC1); //convert to float        result = resizedImageFloat.Reshape(1, 1);        contourIndex = hierarchyIndexes[contourIndex].Next;    }    return result;
}

public CvKNearest TrainData(IList<ImageInfo> trainingImages)
{    var samples = new Mat();    foreach (var trainingImage in trainingImages)    {        samples.PushBack(trainingImage.Image);    }    var labels = trainingImages.Select(x => x.ImageGroupId).ToArray();    var responses = new Mat(labels.Length, 1, MatType.CV_32SC1, labels);    var tmp = responses.Reshape(1, 1); //make continuous    var responseFloat = new Mat();    tmp.ConvertTo(responseFloat, MatType.CV_32FC1); // Convert  to float    var kNearest = new CvKNearest();    kNearest.Train(samples, responseFloat); // Train with sample and responses    return kNearest;
}

public void DoOCR(CvKNearest kNearest, string path)
{    var src = Cv2.ImRead(path);    Cv2.ImShow("Source", src);    var gray = new Mat();    Cv2.CvtColor(src, gray, ColorConversion.BgrToGray);    var threshImage = new Mat();    Cv2.Threshold(gray, threshImage, Thresh, ThresholdMaxVal, ThresholdType.BinaryInv); // Threshold to find contour    Point[][] contours;    HiearchyIndex[] hierarchyIndexes;    Cv2.FindContours(        threshImage,        out contours,        out hierarchyIndexes,        mode: ContourRetrieval.CComp,        method: ContourChain.ApproxSimple);    if (contours.Length == 0)    {        throw new NotSupportedException("Couldn't find any object in the image.");    }    //Create input sample by contour finding and cropping    var dst = new Mat(src.Rows, src.Cols, MatType.CV_8UC3, Scalar.All(0));    var contourIndex = 0;    while ((contourIndex >= 0))    {        var contour = contours[contourIndex];        var boundingRect = Cv2.BoundingRect(contour); //Find bounding rect for each contour        Cv2.Rectangle(src,            new Point(boundingRect.X, boundingRect.Y),            new Point(boundingRect.X + boundingRect.Width, boundingRect.Y + boundingRect.Height),            new Scalar(0, 0, 255),            2);        var roi = new Mat(threshImage, boundingRect); //Crop the image        var resizedImage = new Mat();        var resizedImageFloat = new Mat();        Cv2.Resize(roi, resizedImage, new Size(10, 10)); //resize to 10X10        resizedImage.ConvertTo(resizedImageFloat, MatType.CV_32FC1); //convert to float        var result = resizedImageFloat.Reshape(1, 1);        var results = new Mat();        var neighborResponses = new Mat();        var dists = new Mat();        var detectedClass = (int)kNearest.FindNearest(result, 1, results, neighborResponses, dists);        //Console.WriteLine("DetectedClass: {0}", detectedClass);        //Cv2.ImShow("roi", roi);        //Cv.WaitKey(0);        //Cv2.ImWrite(string.Format("det_{0}_{1}.png",detectedClass, contourIndex), roi);        Cv2.PutText(            dst,            detectedClass.ToString(CultureInfo.InvariantCulture),            new Point(boundingRect.X, boundingRect.Y + boundingRect.Height),            0,            1,            new Scalar(0, 255, 0),            2);        contourIndex = hierarchyIndexes[contourIndex].Next;    }    Cv2.ImShow("Segmented Source", src);    Cv2.ImShow("Detected", dst);    Cv2.ImWrite("dest.jpg", dst);    Cv2.WaitKey();
}

// load the image and convert it to grayscale
var image = new Mat(fileName);
if (rotation != 0)
{    rotateImage(image, image, rotation, 1);
}
if (debug)
{    Cv2.ImShow("Source", image);    Cv2.WaitKey(1); // do events
}
var gray = new Mat();
var channels = image.Channels();
if (channels > 1)
{    Cv2.CvtColor(image, gray, ColorConversion.BgrToGray);
}
else
{    image.CopyTo(gray);
}

// compute the Scharr gradient magnitude representation of the images
// in both the x and y direction
var gradX = new Mat();
Cv2.Sobel(gray, gradX, MatType.CV_32F, xorder: 1, yorder: 0, ksize: -1);
//Cv2.Scharr(gray, gradX, MatType.CV_32F, xorder: 1, yorder: 0);
var gradY = new Mat();
Cv2.Sobel(gray, gradY, MatType.CV_32F, xorder: 0, yorder: 1, ksize: -1);
//Cv2.Scharr(gray, gradY, MatType.CV_32F, xorder: 0, yorder: 1);
// subtract the y-gradient from the x-gradient
var gradient = new Mat();
Cv2.Subtract(gradX, gradY, gradient);
Cv2.ConvertScaleAbs(gradient, gradient);
if (debug)
{    Cv2.ImShow("Gradient", gradient);    Cv2.WaitKey(1); // do events
}

// blur and threshold the image
var blurred = new Mat();
Cv2.Blur(gradient, blurred, new Size(9, 9));
var threshImage = new Mat();
Cv2.Threshold(blurred, threshImage, thresh, 255, ThresholdType.Binary);
if (debug)
{    Cv2.ImShow("Thresh", threshImage);    Cv2.WaitKey(1); // do events
}
// construct a closing kernel and apply it to the thresholded image
var kernel = Cv2.GetStructuringElement(StructuringElementShape.Rect, new Size(21, 7));
var closed = new Mat();
Cv2.MorphologyEx(threshImage, closed, MorphologyOperation.Close, kernel);
if (debug)
{    Cv2.ImShow("Closed", closed);    Cv2.WaitKey(1); // do events
}
// perform a series of erosions and dilations
Cv2.Erode(closed, closed, null, iterations: 4);
Cv2.Dilate(closed, closed, null, iterations: 4);
if (debug)
{    Cv2.ImShow("Erode & Dilate", closed);    Cv2.WaitKey(1); // do events
}

//find the contours in the thresholded image, then sort the contours
//by their area, keeping only the largest one
Point[][] contours;
HiearchyIndex[] hierarchyIndexes;
Cv2.FindContours(    closed,    out contours,    out hierarchyIndexes,    mode: ContourRetrieval.CComp,    method: ContourChain.ApproxSimple);
if (contours.Length == 0)
{    throw new NotSupportedException("Couldn't find any object in the image.");
}
var contourIndex = 0;
var previousArea = 0;
var biggestContourRect = Cv2.BoundingRect(contours[0]);
while ((contourIndex >= 0))
{    var contour = contours[contourIndex];    var boundingRect = Cv2.BoundingRect(contour); //Find bounding rect for each contour    var boundingRectArea = boundingRect.Width * boundingRect.Height;    if (boundingRectArea > previousArea)    {        biggestContourRect = boundingRect;        previousArea = boundingRectArea;    }    contourIndex = hierarchyIndexes[contourIndex].Next;
}
var barcode = new Mat(image, biggestContourRect); //Crop the image
Cv2.CvtColor(barcode, barcode, ColorConversion.BgrToGray);
Cv2.ImShow("Barcode", barcode);
Cv2.WaitKey(1); // do events

 PM> Install-Package ZXing.Net

private static string getBarcodeText(Mat barcode)
{    // `ZXing.Net` needs a white space around the barcode    var barcodeWithWhiteSpace = new Mat(new Size(barcode.Width + 30, barcode.Height + 30), MatType.CV_8U, Scalar.White);    var drawingRect = new Rect(new Point(15, 15), new Size(barcode.Width, barcode.Height));    var roi = barcodeWithWhiteSpace[drawingRect];    barcode.CopyTo(roi);    Cv2.ImShow("Enhanced Barcode", barcodeWithWhiteSpace);    Cv2.WaitKey(1); // do events    return decodeBarcodeText(barcodeWithWhiteSpace.ToBitmap());
}
private static string decodeBarcodeText(System.Drawing.Bitmap barcodeBitmap)
{    var source = new BitmapLuminanceSource(barcodeBitmap);    // using http://zxingnet.codeplex.com/    // PM> Install-Package ZXing.Net    var reader = new BarcodeReader(null, null, ls => new GlobalHistogramBinarizer(ls))    {        AutoRotate = true,        TryInverted = true,        Options = new DecodingOptions        {            TryHarder = true,            //PureBarcode = true,            /*PossibleFormats = new List<BarcodeFormat>                    {                        BarcodeFormat.CODE_128                        //BarcodeFormat.EAN_8,                        //BarcodeFormat.CODE_39,                        //BarcodeFormat.UPC_A                    }*/        }    };    //var newhint = new KeyValuePair<DecodeHintType, object>(DecodeHintType.ALLOWED_EAN_EXTENSIONS, new Object());    //reader.Options.Hints.Add(newhint);    var result = reader.Decode(source);    if (result == null)    {        Console.WriteLine("Decode failed.");        return string.Empty;    }    Console.WriteLine("BarcodeFormat: {0}", result.BarcodeFormat);    Console.WriteLine("Result: {0}", result.Text);    var writer = new BarcodeWriter    {        Format = result.BarcodeFormat,        Options = { Width = 200, Height = 50, Margin = 4},        Renderer = new ZXing.Rendering.BitmapRenderer()    };    var barcodeImage = writer.Write(result.Text);    Cv2.ImShow("BarcodeWriter", barcodeImage.ToMat());    return result.Text;
}

var barcodeClone = barcode.Clone();
var barcodeText = getBarcodeText(barcodeClone);
if (string.IsNullOrWhiteSpace(barcodeText))
{    Console.WriteLine("Enhancing the barcode...");    //Cv2.AdaptiveThreshold(barcode, barcode, 255,        //AdaptiveThresholdType.GaussianC, ThresholdType.Binary, 9, 1);    //var th = 119;    var th = 100;    Cv2.Threshold(barcode, barcode, th, 255, ThresholdType.ToZero);    Cv2.Threshold(barcode, barcode, th, 255, ThresholdType.Binary);    barcodeText = getBarcodeText(barcode);
}
Cv2.Rectangle(image,    new Point(biggestContourRect.X, biggestContourRect.Y),    new Point(biggestContourRect.X + biggestContourRect.Width, biggestContourRect.Y + biggestContourRect.Height),    new Scalar(0, 255, 0),    2);
if (debug)
{    Cv2.ImShow("Segmented Source", image);    Cv2.WaitKey(1); // do events
}
Cv2.WaitKey(0);
Cv2.DestroyAllWindows();

 SELECT * FROM table1 WHERE OrderDate ='12 Mar 2004'

SET @SQL = 'SELECT * FROM table2 WHERE OrderDate = ' + '''' + @Var + ''''
EXEC (@SQL)

  --Forced
ALTER DATABASE dbName SET PARAMETERIZATION FORCED

--Simple
ALTER DATABASE dbName SET PARAMETERIZATION SIMPLE

 use dbName;
-- Optimizing for Ad hoc Workloads
exec sp_configure 'show advanced options',1;
RECONFIGURE;
go
exec sp_configure 'optimize for ad hoc workloads',1;
RECONFIGURE;
Go

public static string FixGmailDots(string email)
{    if (string.IsNullOrWhiteSpace(email))        return string.Empty;    email = email.ToLowerInvariant().Trim();    var emailParts = email.Split('@');    var name = emailParts[0].Replace(".", string.Empty).Replace("+", string.Empty);    var emailDomain = emailParts[1];    string[] domainsAllowedDots =    {        "gmail.com",        "facebook.com"    };    var isFromDomainsAllowedDots = domainsAllowedDots.Any(domain => emailDomain.Equals(domain));    return !isFromDomainsAllowedDots ? email : string.Format("{0}@{1}", name, emailDomain);
}

 friendlyName = friendlyName.ApplyCorrectYeKe().RemoveDiacritics().CleanUnderLines().RemovePunctuation();
var trimmedFriendlyName = friendlyName.Trim().Replace(" ", "");

public static string CleanUnderLines(string text)
{    if (string.IsNullOrWhiteSpace(text))        return string.Empty;    const char chr1600 = (char)1600; //ـ=1600
    const char chr8204 = (char)8204; //‌=8204
 
    return text.Replace(chr1600.ToString(CultureInfo.InvariantCulture), "")               .Replace(chr8204.ToString(CultureInfo.InvariantCulture), "");
}

 public static string RemovePunctuation(string text)
{
 return string.IsNullOrWhiteSpace(text) ? string.Empty : new string(text.Where(c => !char.IsPunctuation(c)).ToArray());
}

 var words = text.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
return words.Length;

[TestMethod]
public void TestInvalidChars()
{    const string data = "To be . ! < > ( ) ! ! , ; : ' ? + -";    Assert.AreEqual(2, data.WordsCount());
}

 var words = text.Split(
    new[] { ' ', ',', ';', '.', '!', '"', '(', ')', '?', ':', '\'', '«' , '»', '+', '-' },
    StringSplitOptions.RemoveEmptyEntries);
return words.Length;

[TestMethod]
public void TestSimpleHtmlSpacesWithNewLine()
{    const string data = "<b>this is&nbsp;a&nbsp;&nbsp;test.</b>\n\r<b>this is&nbsp;a&nbsp;&nbsp;test.</b>";    Assert.AreEqual(8, data.WordsCount());
}

using System;
using System.Text.RegularExpressions;
namespace ReadingTime
{    public static class CalculateWordsCount    {        private static readonly Regex _matchAllTags =            new Regex(@"<(.|\n)*?>", RegexOptions.IgnoreCase | RegexOptions.Compiled);        public static int WordsCount(this string text)        {            if (string.IsNullOrWhiteSpace(text))            {                return 0;            }            text = text.cleanTags().Trim();            text = text.Replace("\t", " ");            text = text.Replace("\n", " ");            text = text.Replace("\r", " ");            var words = text.Split(                new[] { ' ', ',', ';', '.', '!', '"', '(', ')', '?', ':', '\'', '«' , '»', '+', '-' },                StringSplitOptions.RemoveEmptyEntries);            return words.Length;        }        private static string cleanTags(this string data)        {            return data.Replace("\n", "\n ").removeHtmlTags();        }        private static string removeHtmlTags(this string text)        {            return string.IsNullOrEmpty(text) ?                        string.Empty :                        _matchAllTags.Replace(text, " ").Replace("&nbsp;", " ");        }    }
}

using System;
namespace ReadingTime
{    public static class CalculateReadingTime    {        public static string MinReadTime(this string text, int wordsPerMinute = 180)        {            var wordsCount = text.WordsCount();            var minutes = wordsCount / wordsPerMinute;            return minutes == 0 ? "کمتر از یک دقیقه" : TimeSpan.FromMinutes(minutes).toReadableString();        }        private static string toReadableString(this TimeSpan span)        {            var formatted = string.Format("{0}{1}{2}{3}",                span.Duration().Days > 0 ? string.Format("{0:0} روز و ", span.Days) : string.Empty,                span.Duration().Hours > 0 ? string.Format("{0:0} ساعت و ", span.Hours) : string.Empty,                span.Duration().Minutes > 0 ? string.Format("{0:0} دقیقه و ", span.Minutes) : string.Empty,                span.Duration().Seconds > 0 ? string.Format("{0:0} ثانیه", span.Seconds) : string.Empty);            if (formatted.EndsWith("و "))            {                formatted = formatted.Substring(0, formatted.Length - 2);            }            if (string.IsNullOrEmpty(formatted))            {                formatted = "0 ثانیه";
            }            return formatted.Trim();        }    }
}

 C:\Program Files (x86)\Microsoft Visual Studio 14.0>csc /?
Microsoft (R) Visual C# Compiler version 1.0.0.50618
Copyright (C) Microsoft Corporation. All rights reserved.


Visual C# Compiler Options

 /analyzer:<file list> Run the analyzers from this assembly
(Short form: /a)