private void OnGUI()
{
ScrollPos = GUILayout.BeginScrollView(ScrollPos);
ShowSection_Forward = EditorGUILayout.Foldout(ShowSection_Forward, "Forward DFT");
if (ShowSection_Forward)
{
if (GUILayout.Button("Load Source Image"))
{
string path = EditorUtility.OpenFilePanelWithFilters(
"Choose the image file", Application.dataPath,
new string[] { "PNG", "png", "JPEG", "jpg", "JPEG", "jpeg" });
if (path.Length > 0)
{
InitDisplayTex(ref ForwardDFT_Src);
ForwardDFT_Src.LoadImage(File.ReadAllBytes(path));
ForwardDFT_Src.Apply(false, false);
}
}
if (ForwardDFT_Src != null)
{
var texPos = GUILayoutUtility.GetRect(Math.Min(512, ForwardDFT_Src.width),
Math.Min(512, ForwardDFT_Src.height));
GUI.DrawTexture(texPos, ForwardDFT_Src, ScaleMode.ScaleToFit);
GUILayout.Space(15.0f);
if (GUILayout.Button("Run Forward DFT"))
{
var samples = Algo2D.ToSamples(ForwardDFT_Src);
//var dftResults = Algo2D.Forward(samples);
var dftResults = new Complex[samples.GetLength(0), samples.GetLength(1)];
DFT_GPU.Forward((uint)samples.GetLength(0), (uint)samples.GetLength(1),
(x, y) => samples[x, y],
(x, y, c) => dftResults[x, y] = c);
InitDisplayTex(ref ForwardDFT_Dest);
Algo2D.ToTex(dftResults, ForwardDFT_Dest);
}
if (ForwardDFT_Dest != null)
{
texPos = GUILayoutUtility.GetRect(Math.Min(256, ForwardDFT_Dest.width),
Math.Min(256, ForwardDFT_Dest.height));
GUI.DrawTexture(texPos, ForwardDFT_Dest, ScaleMode.ScaleToFit);
GUILayout.BeginHorizontal();
if (GUILayout.Button("Shift"))
{
ForwardDFT_Dest.Filter(
(x, y, c, pixels) =>
{
x = (x + (ForwardDFT_Dest.width / 2)) % ForwardDFT_Dest.width;
y = (y + (ForwardDFT_Dest.height / 2)) % ForwardDFT_Dest.height;
return(pixels[x + (y * ForwardDFT_Dest.width)]);
});
}
if (GUILayout.Button("Map to [0, 1]"))
{
//A continuous 1:1 mapping from (-inf, +inf) to (0, 1) is:
// 1/(1+e^(-x))
ForwardDFT_Dest.Filter(f => (1.0f / (1.0f + Mathf.Exp(-f))));
}
if (GUILayout.Button("Map to [-inf, +inf]"))
{
//The inverse of the above mapping is:
// ln(-x/(x-1))
ForwardDFT_Dest.Filter(f => Mathf.Log(-f / (f - 1)));
}
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
ScaleVal = EditorGUILayout.FloatField("Log Scale: ", ScaleVal);
if (GUILayout.Button("Forward"))
{
ForwardDFT_Dest.Filter(f => (ScaleVal * Mathf.Log(f + 1)));
}
if (GUILayout.Button("Invert"))
{
//Use the inverse of the "forward" scale.
ForwardDFT_Dest.Filter(f => (Mathf.Exp(f / ScaleVal) - 1.0f));
}
GUILayout.EndHorizontal();
}
GUILayout.Space(15.0f);
if (ForwardDFT_Dest != null)
{
if (GUILayout.Button("Save Forward DFT"))
{
string path = EditorUtility.SaveFilePanel("Choose the location",
Application.dataPath,
"DFT", "png");
if (path.Length > 0)
{
File.WriteAllBytes(path, ForwardDFT_Dest.EncodeToPNG());
}
}
}
}
}
GUILayout.Space(30.0f);
ShowSection_Inverse = EditorGUILayout.Foldout(ShowSection_Inverse, "Inverse DFT");
if (ShowSection_Inverse)
{
GUILayout.BeginHorizontal();
if (GUILayout.Button("Load DFT Img"))
{
string path = EditorUtility.OpenFilePanelWithFilters(
"Choose the DFT image file", Application.dataPath,
new string[] { "JPEG", "jpeg", "JPEG", "jpg", "PNG", "png" });
if (path.Length > 0)
{
InitDisplayTex(ref InverseDFT_Src);
InverseDFT_Src.LoadImage(File.ReadAllBytes(path));
InverseDFT_Src.Apply(false, false);
}
}
if (ForwardDFT_Dest != null && GUILayout.Button("Copy DFT Img"))
{
InitDisplayTex(ref InverseDFT_Src);
ForwardDFT_Dest.CopyTo(InverseDFT_Src);
}
GUILayout.EndHorizontal();
if (InverseDFT_Src != null)
{
var texPos = GUILayoutUtility.GetRect(Math.Min(256, InverseDFT_Src.width),
Math.Min(256, InverseDFT_Src.height));
GUI.DrawTexture(texPos, InverseDFT_Src, ScaleMode.ScaleToFit);
GUILayout.BeginHorizontal();
if (GUILayout.Button("Map to [0, 1]"))
{
//A continuous 1:1 mapping from (-inf, +inf) to (0, 1) is:
// 1/(1+e^(-x))
InverseDFT_Src.Filter(f => (1.0f / (1.0f + Mathf.Exp(-f))));
}
if (GUILayout.Button("Map to [-inf, +inf]"))
{
//The inverse of the above mapping is:
// ln(-x/(x-1))
InverseDFT_Src.Filter(f => Mathf.Log(-f / (f - 1)));
}
GUILayout.EndHorizontal();
GUILayout.Space(15.0f);
if (GUILayout.Button("Run Inverse DFT"))
{
var samples = Algo2D.ToSamples(InverseDFT_Src);
var results = Algo2D.Inverse(samples);
InitDisplayTex(ref InverseDFT_Dest);
Algo2D.ToTex(results, InverseDFT_Dest);
}
if (InverseDFT_Dest != null)
{
texPos = GUILayoutUtility.GetRect(Math.Min(512, InverseDFT_Dest.width),
Math.Min(512, InverseDFT_Dest.height));
GUI.DrawTexture(texPos, InverseDFT_Dest, ScaleMode.ScaleToFit);
}
GUILayout.Space(15.0f);
if (InverseDFT_Dest != null)
{
if (GUILayout.Button("Save Inverse DFT"))
{
string path = EditorUtility.SaveFilePanel("Choose the location",
Application.dataPath,
"DFT", "png");
if (path.Length > 0)
{
File.WriteAllBytes(path, InverseDFT_Dest.EncodeToPNG());
}
}
}
}
}
GUILayout.EndScrollView();
}
public override void OnInspectorGUI()
{
base.OnInspectorGUI();
var script = (DFTTestScript)target;
GUILayout.Space(20.0f);
//Button to sample from time signal.
GUILayout.BeginHorizontal();
NSamples = EditorGUILayout.IntField(NSamples);
if (NSamples < 2)
{
NSamples = 2;
}
if (GUILayout.Button("Sample " + NSamples.ToString() + " points"))
{
timeSamples = DFTTestScript.GetDiscreteTimeSignal(script.TimeSignal, NSamples);
var newKeys = new Keyframe[timeSamples.Length];
float timeIncrement = 1.0f / (timeSamples.Length - 1);
for (int sampleI = 0; sampleI < timeSamples.Length; ++sampleI)
{
newKeys[sampleI] = new Keyframe(sampleI * timeIncrement, timeSamples[sampleI]);
}
script.SampledTimeSignal.keys = newKeys;
script.CloneCurve(ref script.SampledTimeSignal);
Repaint();
}
GUILayout.EndHorizontal();
useGPU = GUILayout.Toggle(useGPU, "Use GPU");
//Button to perform forward DFT.
if (GUILayout.Button("Perform Forward DFT"))
{
if (useGPU)
{
dftResults = new Complex[timeSamples.Length];
string errMsg = DFT_GPU.Forward((uint)timeSamples.Length, 1,
(x, y) => timeSamples[x],
(x, y, c) => dftResults[x] = c);
if (errMsg.Length > 0)
{
Debug.LogError(errMsg);
}
}
else
{
Complex[,] _timeSamples = new Complex[timeSamples.Length, 1];
for (int i = 0; i < timeSamples.Length; ++i)
{
_timeSamples[i, 0] = new Complex(timeSamples[i], 0.0f);
}
var _dftResults = Algo2D.Forward(_timeSamples);
dftResults = new Complex[timeSamples.Length];
for (int i = 0; i < timeSamples.Length; ++i)
{
dftResults[i] = _dftResults[i, 0];
}
//dftResults = Algo1D.Forward(timeSamples.Select(f => new Complex(f, 0.0f)).ToArray());
}
var newKeys_Cosine = new Keyframe[dftResults.Length];
var newKeys_Sine = new Keyframe[dftResults.Length];
for (int sampleI = 0; sampleI < dftResults.Length; ++sampleI)
{
newKeys_Cosine[sampleI] = new Keyframe(sampleI, dftResults[sampleI].R);
newKeys_Sine[sampleI] = new Keyframe(sampleI, dftResults[sampleI].I);
}
script.CosFrequencySignal.keys = newKeys_Cosine;
script.SinFrequencySignal.keys = newKeys_Sine;
script.CloneCurve(ref script.CosFrequencySignal);
script.CloneCurve(ref script.SinFrequencySignal);
}
//Button to perform inverse DFT.
if (GUILayout.Button("Perform inverse DFT"))
{
float[] results = null;
if (useGPU)
{
results = new float[dftResults.Length];
string errMsg = DFT_GPU.Inverse((uint)results.Length, 1,
(x, y) => dftResults[x],
(x, y, c) => results[x] = c);
if (errMsg.Length > 0)
{
Debug.LogError(errMsg);
}
}
else
{
Complex[,] _dftResults = new Complex[dftResults.Length, 1];
for (int i = 0; i < dftResults.Length; ++i)
{
_dftResults[i, 0] = dftResults[i];
}
var _results = Algo2D.Inverse(_dftResults);
results = new float[dftResults.Length];
for (int i = 0; i < results.Length; ++i)
{
results[i] = _results[i, 0].R;
}
//results = Algo1D.Inverse(dftResults).Select(c => c.R).ToArray();
}
var newKeys = new Keyframe[results.Length];
float timeIncrement = 1.0f / (results.Length - 1);
for (int sampleI = 0; sampleI < results.Length; ++sampleI)
{
newKeys[sampleI] = new Keyframe(sampleI * timeIncrement, results[sampleI]);
}
script.ReconstructedTimeSignal.keys = newKeys;
script.CloneCurve(ref script.ReconstructedTimeSignal);
}
}