امتیاز موضوع:
  • 13 رای - 2.08 میانگین
  • 1
  • 2
  • 3
  • 4
  • 5
کد ssim در سی شارپ
#1
درود دوستان
کسی سورس کد ssim را در سی شارپ داره؟
سپاسگزار میشم بهم بدین
مسی بوس Heart
پاسخ
#2
درود
لطفا عکس نمایتون رو تغییر بدید !

کد الگوریتم ssim برای پردازش تصاویر :

[code] // Compute Structural Similarity Index (SSIM) image quality metrics                                                                                
// See http://www.ece.uwaterloo.ca/~z70wang/research/ssim/                                                                                          
// C# implementation Copyright Chris Lomont 2009-2011                                                                                              
// Send fixes and comments to WWW://LOMONT.ORG                                                                                                        
                                                                                                                                                   
/* History:                                                                                                                                        
* June 2011                                                                                                                                        
* 0.91 - Fix to Bitmap creation to prevent locking file handles                                                                                    
*                                                                                                                                                  
* Sept 2009                                                                                                                                        
* 0.9  - Initial Release                                                                                                                          
*                                                                                                                                                  
*                                                                                                                                                  
*/                                                                                                                                                
                                                                                                                                                   
using System;                                                                                                                                      
using System.Drawing;                                                                                                                              
                                                                                                                                                   
namespace Lomont                                                                                                                                    
   {                                                                                                                                              
   class SSIM                                                                                                                                      
       {                                                                                                                                          
       /// <summary>                                                                                                                              
       /// The version of the SSIM code                                                                                                            
       /// </summary>                                                                                                                              
       internal static string Version { get { return "0.91";} }                                                                                    
                                                                                                                                                   
       /// <summary>                                                                                                                              
       /// Compute from two linear ushort grayscale images with given size and bitdepth                                                            
       /// </summary>                                                                                                                              
       /// <param name="img1">Image 1 data</param>                                                                                                
       /// <param name="img2">Image 2 data</param>                                                                                                
       /// <param name="w">width</param>                                                                                                          
       /// <param name="h">height</param>                                                                                                          
       /// <param name="depth">Bit depth (1-16)</param>                                                                                            
       /// <returns></returns>                                                                                                                    
       internal double Index(ushort[] img1, ushort[] img2, int w, int h, int depth)                                                                
           {                                                                                                                                      
           L = (1 << depth) - 1;                                                                                                                  
           return ComputeSSIM(ConvertLinear(img1, w, h), ConvertLinear(img2, w, h));                                                              
           }                                                                                                                                      
                                                                                                                                                   
       /// <summary>                                                                                                                              
       /// Take two System.Drawing.Bitmaps                                                                                                        
       /// </summary>                                                                                                                              
       /// <param name="img1"></param>                                                                                                            
       /// <param name="img2"></param>                                                                                                            
       /// <returns></returns>                                                                                                                    
       internal double Index(Bitmap img1, Bitmap img2)                                                                                            
           {                                                                                                                                      
           L = 255; // todo - this assumes 8 bit, but color conversion later is always 8 bit, so ok?                                              
           return ComputeSSIM(ConvertBitmap(img1), ConvertBitmap(img2));                                                                          
           }                                                                                                                                      
                                                                                                                                                   
       /// <summary>                                                                                                                              
       /// Take two filenames                                                                                                                      
       /// </summary>                                                                                                                              
       /// <param name="filename1"></param>                                                                                                        
       /// <param name="filename2"></param>                                                                                                        
       /// <returns></returns>                                                                                                                    
       internal double Index(string filename1, string filename2)                                                                                  
           {                                                                                                                                      
           using (var b1 = new Bitmap(filename1))                                                                                                  
           using (var b2 = new Bitmap(filename2))                                                                                                  
               return Index(b1,b2);                                                                                                                
           }                                                                                                                                      
                                                                                                                                                   
       #region Implementation                                                                                                                      
                                                                                                                                                   
       #region Locals                                                                                                                              
       // default settings, names from paper                                                                                                      
       internal double K1 = 0.01, K2 = 0.03;                                                                                                      
       internal double L = 255;                                                                                                                    
       readonly Grid window = Gaussian(11, 1.5);                                                                                                  
       #endregion                                                                                                                                  
                                                                                                                                                   
       /// <summary>                                                                                                                              
       /// Compute the SSIM index of two same sized Grids                                                                                          
       /// </summary>                                                                                                                              
       /// <param name="img1">The first Grid</param>                                                                                              
       /// <param name="img2">The second Grid</param>                                                                                              
       /// <returns>SSIM index</returns>                                                                                                          
       double ComputeSSIM(Grid img1, Grid img2)                                                                                                    
           {                                                                                                                                      
           // uses notation from paper                                                                                                            
           // automatic downsampling                                                                                                              
           int f = (int)Math.Max(1, Math.Round(Math.Min(img1.width,img1.height) / 256.0));                                                        
           if (f > 1)                                                                                                                              
               { // downsampling by f                                                                                                              
                 // use a simple low-pass ....... and subsample by f                                                                                
               img1 = SubSample(img1, f);                                                                                                          
               img2 = SubSample(img2, f);                                                                                                          
               }                                                                                                                                  
                                                                                                                                                   
           // normalize window - todo - do in window set {}                                                                                        
           double scale = 1.0/window.Total;                                                                                                        
           Grid.Op((i, j) => window[i, j] * scale, window);                                                                                        
                                                                                                                                                   
           // image statistics                                                                                                                    
           var mu1 = .......(img1, window);                                                                                                        
           var mu2 = .......(img2, window);                                                                                                        
                                                                                                                                                   
           var mu1mu2 = mu1 * mu2;                                                                                                                
           var mu1SQ  = mu1 * mu1;                                                                                                                
           var mu2SQ  = mu2 * mu2;                                                                                                                
                                                                                                                                                   
           var sigma12  = .......(img1 * img2, window) - mu1mu2;                                                                                    
           var sigma1SQ = .......(img1 * img1, window) - mu1SQ;                                                                                    
           var sigma2SQ = .......(img2 * img2, window) - mu2SQ;                                                                                    
                                                                                                                                                   
           // constants from the paper                                                                                                            
           double C1 = K1 * L; C1 *= C1;                                                                                                          
           double C2 = K2 * L; C2 *= C2;                                                                                                          
                                                                                                                                                   
           Grid ssim_map = null;                                                                                                                  
           if ((C1 > 0) && (C2 > 0))                                                                                                              
               {                                                                                                                                  
               ssim_map = Grid.Op((i, j) =>                                                                                                        
                   (2 * mu1mu2[i, j] + C1) * (2 * sigma12[i, j] + C2) /                                                                            
                   (mu1SQ[i, j] + mu2SQ[i, j] + C1) / (sigma1SQ[i, j] + sigma2SQ[i, j] + C2),                                                      
                   new Grid(mu1mu2.width, mu1mu2.height));                                                                                        
               }                                                                                                                                  
           else                                                                                                                                    
               {                                                                                                                                  
               var num1 = Linear(2, mu1mu2, C1);                                                                                                  
               var num2 = Linear(2, sigma12, C2);                                                                                                  
               var den1 = Linear(1, mu1SQ + mu2SQ, C1);                                                                                            
               var den2 = Linear(1, sigma1SQ + sigma2SQ, C2);                                                                                      
                                                                                                                                                   
               var den = den1 * den2; // total denominator                                                                                        
               ssim_map = new Grid(mu1.width, mu1.height);                                                                                        
               for (int i = 0; i < ssim_map.width; ++i)                                                                                            
                   for (int j = 0; j < ssim_map.height; ++j)                                                                                      
                       {                                                                                                                          
                       ssim_map[i, j] = 1;                                                                                                        
                       if (den[i, j] > 0)                                                                                                          
                           ssim_map[i, j] = num1[i, j] * num2[i, j] / (den1[i, j] * den2[i, j]);                                                  
                       else if ((den1[i, j] != 0) && (den2[i, j] == 0))                                                                            
                           ssim_map[i, j] = num1[i, j] / den1[i, j];                                                                              
                       }                                                                                                                          
               }                                                                                                                                  
                                                                                                                                                   
           // average all values                                                                                                                  
           return ssim_map.Total / (ssim_map.width * ssim_map.height);                                                                            
           } // ComputeSSIM                                                                                                                        
                                                                                                                                                   
                                                                                                                                                   
       #region Grid                                                                                                                                
       /// <summary>                                                                                                                              
       /// Hold a grid of doubles as an array with appropriate operators                                                                          
       /// </summary>                                                                                                                              
       class Grid                                                                                                                                  
           {                                                                                                                                      
           double[,] data;                                                                                                                        
           internal int width, height;                                                                                                            
           internal Grid(int w, int h)                                                                                                            
               {                                                                                                                                  
               data = new double[w, h];                                                                                                            
               width = w;                                                                                                                          
               height = h;                                                                                                                        
               }                                                                                                                                  
                                                                                                                                                   
           /// <summary>                                                                                                                          
           /// Indexer to read the i,j item                                                                                                        
           /// </summary>                                                                                                                          
           /// <param name="i"></param>                                                                                                            
           /// <param name="j"></param>                                                                                                            
           /// <returns></returns>                                                                                                                
           internal double this[int i, int j]                                                                                                      
               {                                                                                                                                  
               get { return data[i, j]; }                                                                                                          
               set { data[i, j] = value; }                                                                                                        
               }                                                                                                                                  
                                                                                                                                                   
           /// <summary>                                                                                                                          
           /// Get the summed value from the Grid                                                                                                  
           /// </summary>                                                                                                                          
           internal double Total                                                                                                                  
               {                                                                                                                                  
               get                                                                                                                                
                   {                                                                                                                              
                   double s = 0;                                                                                                                  
                   foreach (var d in data) s += d;                                                                                                
                   return s;                                                                                                                      
                   }                                                                                                                              
               }                                                                                                                                  
                                                                                                                                                   
           /// <summary>                                                                                                                          
           /// componentwise addition of Grids                                                                                                    
           /// </summary>                                                                                                                          
           /// <param name="a"></param>                                                                                                            
           /// <param name="b"></param>                                                                                                            
           /// <returns></returns>                                                                                                                
           static public Grid operator+(Grid a, Grid b)                                                                                            
               {                                                                                                                                  
               return Op((i,j)=>a[i,j]+b[i,j],new Grid(a.width,a.height));                                                                        
               }                                                                                                                                  
                                                                                                                                                   
           /// <summary>                                                                                                                          
           /// componentwise subtraction of Grids                                                                                                  
           /// </summary>                                                                                                                          
           /// <param name="a"></param>                                                                                                            
           /// <param name="b"></param>                                                                                                            
           /// <returns></returns>                                                                                                                
           static public Grid operator-(Grid a, Grid b)                                                                                            
               {                                                                                                                                  
               return Op((i, j) => a[i, j] - b[i, j], new Grid(a.width, a.height));                                                                
               }                                                                                                                                  
                                                                                                                                                   
           /// <summary>                                                                                                                          
           /// componentwise multiplication of Grids                                                                                              
           /// </summary>                                                                                                                          
           /// <param name="a"></param>                                                                                                            
           /// <param name="b"></param>                                                                                                            
           /// <returns></returns>                                                                                                                
           static public Grid operator*(Grid a, Grid b)                                                                                            
               {                                                                                                                                  
               return Op((i, j) => a[i, j] * b[i, j], new Grid(a.width, a.height));                                                                
               }                                                                                                                                  
                                                                                                                                                   
           /// <summary>                                                                                                                          
           /// componentwise division of Grids                                                                                                    
           /// </summary>                                                                                                                          
           /// <param name="a"></param>                                                                                                            
           /// <param name="b"></param>                                                                                                            
           /// <returns></returns>                                                                                                                
           static public Grid operator/(Grid a, Grid b)                                                                                            
               {                                                                                                                                  
               return Op((i, j) => a[i, j] / b[i, j], new Grid(a.width, a.height));                                                                
               }                                                                                                                                  
                                                                                                                                                   
           /// <summary>                                                                                                                          
           /// Generic function maps (i,j) onto the given grid                                                                                    
           /// </summary>                                                                                                                          
           /// <param name="f"></param>                                                                                                            
           /// <param name="a"></param>                                                                                                            
           /// <returns></returns>                                                                                                                
           static internal Grid Op(Func<int,int,double> f,Grid g)                                                                                  
               {                                                                                                                                  
               int w = g.width, h = g.height;                                                                                                      
               for (int i = 0; i < w; ++i)                                                                                                        
                   for (int j = 0; j < h; ++j)                                                                                                    
                       g[i, j] = f(i,j);                                                                                                          
               return g;                                                                                                                          
               }                                                                                                                                  
                                                                                                                                                   
           } // class Grid                                                                                                                        
       #endregion //Grid                                                                                                                          
                                                                                                                                                   
                                                                                                                                                   
       /// <summary>                                                                                                                              
       /// Create a gaussian window of the given size and standard deviation                                                                      
       /// </summary>                                                                                                                              
       /// <param name="size">Odd number</param>                                                                                                  
       /// <param name="sigma">Gaussian std deviation</param>                                                                                      
       /// <returns></returns>                                                                                                                    
       static Grid Gaussian(int size, double sigma)                                                                                                
           {                                                                                                                                      
           var ....... = new Grid(size, size);                                                                                                      
           double s2 = sigma * sigma, c = (size-1)/2.0, dx, dy;                                                                                    
                                                                                                                                                   
           Grid.Op((i, j) =>                                                                                                                      
               {                                                                                                                                  
                   dx = i - c;                                                                                                                    
                   dy = j - c;                                                                                                                    
                   return Math.Exp(-(dx * dx + dy * dy) / (2 * s2));                                                                              
               },                                                                                                                                  
               .......);                                                                                                                            
           var scale = 1.0/........Total;                                                                                                          
           Grid.Op((i, j) => .......[i, j] * scale, .......);                                                                                        
           return .......;                                                                                                                          
           }                                                                                                                                      
                                                                                                                                                   
       /// <summary>                                                                                                                              
       /// subsample a grid by step size, averaging each box into the result value                                                                
       /// </summary>                                                                                                                              
       /// <returns></returns>                                                                                                                    
       static Grid SubSample(Grid img, int skip)                                                                                                  
           {                                                                                                                                      
           int w = img.width;                                                                                                                      
           int h = img.height;                                                                                                                    
           double scale = 1.0 / (skip * skip);                                                                                                    
           var ans = new Grid(w / skip, h / skip);                                                                                                
           for (int i = 0; i < w-skip ; i+=skip)                                                                                                  
               for (int j = 0; j < h-skip ; j+=skip)                                                                                              
                   {                                                                                                                              
                   double sum = 0;                                                                                                                
                   for (int x = i; x < i + skip; ++x)                                                                                              
                       for (int y = j; y < j+ skip; ++y)                                                                                          
                           sum += img[x, y];                                                                                                      
                   ans[i/skip, j/skip] = sum * scale;                                                                                              
                   }                                                                                                                              
           return ans;                                                                                                                            
           }                                                                                                                                      
                                                                                                                                                   
       /// <summary>                                                                                                                              
       /// Apply ......., return only center part.                                                                                                  
       /// C = .......(A,B) should be same as matlab filter2( ,'valid')                                                                            
       /// </summary>                                                                                                                              
       /// <returns></returns>                                                                                                                    
       static Grid .......(Grid a, Grid b)                                                                                                          
           {                                                                                                                                      
#if false                                                                                                                                          
           int ax = a.width, ay = a.height;                                                                                                        
           int bx = b.width, by = b.height;                                                                                                        
           int bcx = (bx + 1) / 2, bcy = (by + 1) / 2; // center position                                                                          
           var c = new Grid(ax - bx + 1, ay - by + 1);                                                                                            
           for (int i = bx - bcx + 1; i < ax - bx; ++i)                                                                                            
               for (int j = by - bcy + 1; j < ay - by;
خرید کالا زیر قیمت بازار !
amshop.ir
http://www.am-shop.ir/
پاسخ
#3
سپاسگزار لطف کردین

[/url][url=http://www.nikan.ir]طراحی سایت

گیت فروشگاهی
تجهیزات اداری
ترخیص کالا از گمرک
ایمپلنت
دزدگیر فروشگاهی
پاسخ
#4
خیلی سپاسگزار از وقتی که گذاشتید عالی بود.



راههای موفقیت در زندگی
خودباور
پاسخ
#5
سپاسگزارم سپاسگزار از شما.
پاسخ


موضوعات مشابه ...
موضوع نویسنده پاسخ بازدید آخرین ارسال
  سورس کد ساخت فایل pdf (سی شارپ) Amin_Mansouri 3 8,127 07-01-2017، 10:05 AM
آخرین ارسال: 7seo
  کد سی شارپ Save,SaveAs razi0tn 0 1,889 01-19-2016، 02:53 PM
آخرین ارسال: razi0tn
  سورس کد اضافه ,ویرایش,حذف,جستجو در دیتابیس(سی شارپ) Amin_Mansouri 6 18,827 12-09-2015، 08:17 AM
آخرین ارسال: Amin_Mansouri
  سورس کد تبدیل متن به صدا (سی شارپ) Amin_Mansouri 7 10,384 12-18-2013، 12:51 PM
آخرین ارسال: sal
  سورس کد بدست اوردن تعداد کلمات یک رشته ( سی شارپ) Amin_Mansouri 4 8,915 12-17-2013، 11:46 AM
آخرین ارسال: sal
  سورس کد دانلود فایل به زبان سی شارپ Amin_Mansouri 3 8,620 07-06-2013، 09:19 AM
آخرین ارسال: mitranasimy
  سورس کد خواندن و نوشتن در اکسل(سی شارپ دات نت) Amin_Mansouri 3 16,495 03-07-2013، 03:15 PM
آخرین ارسال: mnx_2012
  سورس کد الگوریتم رمزنگاری AES (سی شارپ) Amin_Mansouri 1 10,582 12-31-2012، 09:27 AM
آخرین ارسال: hamidshirazi
  سورس کد تشخیص دادن نصب انتی ویروس بر روی سیستم(سی شارپ) Amin_Mansouri 0 3,236 06-16-2012، 07:28 PM
آخرین ارسال: Amin_Mansouri
  سورس ها یا کد های : Cut , Copy , Paste در سی شارپ Javad_shiri_esf 3 8,605 06-04-2012، 08:32 PM
آخرین ارسال: Amin_Mansouri

پرش به انجمن:


کاربران در حال بازدید این موضوع: 1 مهمان
This forum uses Lukasz Tkacz MyBB addons.