Plugins/FFT/FFT.cs

   1 using System;
   2 using System.Xml;
   3 using Mono.Unix;
   4
   5 namespace Eithne
   6 {
   7         public class FFTInfo : IInfo
   8         {
   9                 public override string Name
  10                 {
  11                         get { return Catalog.GetString("Fast Fourier Transform"); }
  12                 }
  13
  14                 public override string ShortName
  15                 {
  16                         get { return "FFT"; }
  17                 }
  18
  19                 public override string Author
  20                 {
  21                         get { return "Bartosz Taudul"; }
  22                 }
  23
  24                 public override string Description
  25                 {
  26                         get { return Catalog.GetString("This plugin performs fast fourier transform."); }
  27                 }
  28         }
  29
  30         public class FFTFactory : IFactory
  31         {
  32                 IInfo _info = new FFTInfo();
  33                 public IInfo Info
  34                 {
  35                         get { return _info; }
  36                 }
  37
  38                 public IType Type
  39                 {
  40                         get { return IType.ImgProc; }
  41                 }
  42
  43                 public void Initialize()
  44                 {
  45                 }
  46
  47                 public Plugin.Base Create()
  48                 {
  49                         return new FFTPlugin();
  50                 }
  51         }
  52
  53         public class FFTPlugin : Plugin.ImgProc
  54         {
  55                 private bool zero = true;
  56                 private float progress = 0;
  57
  58                 public FFTPlugin()
  59                 {
  60                         _info = new FFTInfo();
  61                 }
  62
  63                 public override XmlNode Config
  64                 {
  65                         get { return GetConfig(); }
  66                         set { LoadConfig(value); }
  67                 }
  68
  69                 private void UpdateValue(bool z)
  70                 {
  71                         zero = z;
  72                         _block.SlotsChanged();
  73                 }
  74
  75                 public override void Setup()
  76                 {
  77                         new FFTSetup(zero, UpdateValue, false);
  78                 }
  79
  80                 public override void Work()
  81                 {
  82                         progress = 0;
  83
  84                         ICommImage socket = _in[0] as ICommImage;
  85                         IImage[] img = socket.Images;
  86                         IImage[] res = new IImage[img.Length];
  87                         _out = new CommSocket(1);
  88
  89                         PreparePlan(img[0].W, img[0].H);
  90
  91                         for(int i=0; i<img.Length; i++)
  92                         {
  93                                 res[i] = FFT(img[i]);
  94                                 progress = (float)i/img.Length;
  95                         }
  96
  97                         _out[0] = new ICommImage(res, socket.OriginalImages, socket.Categories);
  98
  99                         FFTW.Cleanup();
 100
 101                         _workdone = true;
 102                 }
 103
 104                 // this function does nothing, but without it, when first plan is created using real images, for some parameters
 105                 // the first output image is empty and the rest is fine, so it's better to create here this no-use plan just
 106                 // to be sure that everything works
 107                 private void PreparePlan(int w, int h)
 108                 {
 109                         double[] d1 = new double[w * h * 2];
 110                         double[] d2 = new double[w * h * 2];
 111
 112                         IntPtr plan = FFTW.PlanDFT2D(h, w, d1, d2, FFTW.Direction.Forward, 0);
 113
 114                         FFTW.DestroyPlan(plan);
 115                 }
 116
 117                 private IImage FFT(IImage img)
 118                 {
 119                         double[] datain = new double[img.W * img.H * 2];
 120                         double[] dataout = new double[img.W * img.H * 2];
 121
 122                         for(int y=0; y<img.H; y++)
 123                                 for(int x=0; x<img.W; x++)
 124                                 {
 125                                         datain[(x + y*img.W) * 2] = (byte)img[x, y];
 126                                         datain[(x + y*img.W) * 2 + 1] = 0;
 127                                 }
 128
 129                         IntPtr plan = FFTW.PlanDFT2D(img.H, img.W, datain, dataout, FFTW.Direction.Forward, 0);
 130
 131                         FFTW.Execute(plan);
 132
 133                         FFTW.DestroyPlan(plan);
 134
 135                         IImage ret = new IImage(BPP.Float, img.W, img.H);
 136
 137                         for(int y=0; y<img.H; y++)
 138                                 for(int x=0; x<img.W; x++)
 139                                 {
 140                                         double re = dataout[(x + y*img.W) * 2];
 141                                         double im = dataout[(x + y*img.W) * 2 + 1];
 142                                         double val = Math.Sqrt(re * re + im * im);
 143
 144                                         int newx = (x + img.W/2)%img.W;
 145                                         int newy = (y + img.H/2)%img.H;
 146
 147                                         ret[newx, newy] = (float)val/255f;
 148                                 }
 149
 150                         if(zero)
 151                                 ret[img.W/2, img.H/2] = 0f;
 152
 153                         return ret;
 154                 }
 155
 156                 public override void Lock()
 157                 {
 158                         FFTW.mutex.WaitOne();
 159                 }
 160
 161                 public override void Unlock()
 162                 {
 163                         FFTW.mutex.ReleaseMutex();
 164                 }
 165
 166                 private XmlNode GetConfig()
 167                 {
 168                         XmlNode root = _xmldoc.CreateNode(XmlNodeType.Element, "config", "");
 169
 170                         if(zero)
 171                                 root.InnerText = "1";
 172                         else
 173                                 root.InnerText = "0";
 174
 175                         return root;
 176                 }
 177
 178                 private void LoadConfig(XmlNode root)
 179                 {
 180                         if(root.InnerText == "1")
 181                                 UpdateValue(true);
 182                         else
 183                                 UpdateValue(false);
 184                 }
 185
 186                 public override int NumIn               { get { return 1; } }
 187                 public override int NumOut              { get { return 1; } }
 188
 189                 public override string DescIn(int n)
 190                 {
 191                         return Catalog.GetString("Input image.");
 192                 }
 193
 194                 public override string DescOut(int n)
 195                 {
 196                         return Catalog.GetString("FFT of image.");
 197                 }
 198
 199                 private static string[] matchin   = new string[] { "image/grayscale" };
 200                 private static string[] matchout  = new string[] { "image/float" };
 201
 202                 public override string[] MatchIn        { get { return matchin; } }
 203                 public override string[] MatchOut       { get { return matchout; } }
 204
 205                 public override float Progress { get { return progress; } }
 206         }
 207 }