Initial version

Author: mfalt

src/InteractiveControlPlots.jl

@@ -1,5 +1,33 @@
 module InteractiveControlPlots
 
+using ControlSystems, GtkInteract, Immerse
+import Colors, Reactive, Measures, Compose
+
+export bode_immerse, nyquist_immerse, pzmap_immerse, timeplot_immerse
+export labelf, null_theme
+export example_minimal, example_fo_sys
+
+
 # package code goes here
+include("framework.jl")
+include("plots.jl")
+
+examples = ["minimal", "fo_sys"]
+for ex in examples
+    funcname = Symbol("example_$(ex)")
+    @eval begin
+        function $funcname()
+          pdir = joinpath(Pkg.dir("InteractiveControlPlots"),"src")
+          include(joinpath(Pkg.dir("InteractiveControlPlots"),"src/examples/"*$ex*".jl"))
+        end
+    end
+end
+# function example_minimal()
+#     include(joinpath(pdir,"examples/minimal.jl"))
+# end
+# function example_fo_sys()
+#     include(joinpath(pdir,"examples/fo_sys.jl"))
+# end
+
 
 end # module

src/examples/fo_sys.jl

@@ -0,0 +1,59 @@
+# load init commands
+using InteractiveControlPlots, ControlSystems, GtkInteract
+
+# create sliders etc
+x = linspace(-1,1,2)
+ws = logspace(-2,2,1000)
+k=slider(1:0.1:3, label="K")
+logT = slider(-1:0.01:1, label="T")
+f1 = checkbox(false,label="Bode plot  ")
+f2 = checkbox(false,label="Nyquist plot  ")
+f3 = checkbox(false,label="PZ map  ")
+f4 = checkbox(false,label="Step plot  ")
+
+
+# create window
+cg1 = cairographic(width=200,height=150)
+cg2 = cairographic(width=200,height=150)
+cg3 = cairographic(width=200,height=150)
+cg4 = cairographic(width=200,height=150)
+lT = label("T: ")
+
+vbl(w, len) = vbox(label(w.label),hbox(hskip(len),w))
+vbl(w) = vbox(label(w.label),w)
+
+w = window(vbox(hbox(vbl(k),
+    vbox(lT,logT),
+    vbox(vbl(f1,25),vbl(f3,15)),
+    vbox(vbl(f2,35),vbl(f4,22))),
+    hbox(grow(cg1), grow(cg2)),
+    hbox(grow(cg3), grow(cg4))),
+    title="Example")
+
+# loop over parameters
+Reactive.preserve(map(k,logT,f1,f2,f3,f4) do k,logT,f1,f2,f3,f4
+  T = 10^logT
+
+  #Create the 2nd order system
+  sys = tf(k*[1,1],[1, T, 1])
+
+  #Create the plots
+  fig1 = bode_immerse(sys, ws, 1e-2, 1e2) #Ylims = (1e-2, 1e2)
+  fig2 = nyquist_immerse(sys, ws, -2, 2, -2, 2) #x and ylims
+  fig3 = pzmap_immerse(sys,-4,4,-4,4) # x and ylims
+  y,t,x = step(sys, 10)
+  fig4 = timeplot_immerse(t, y, 0, 4) #ylims
+
+  #Update the text
+  push!(lT, "T: " * string(round(T,2)))
+
+  #Push figures
+  push!(cg1, f1 ? fig1 : nothing)
+  push!(cg2, f2 ? fig2 : nothing)
+  push!(cg3, f3 ? fig3 : nothing)
+  push!(cg4, f4 ? fig4 : nothing)
+
+end)
+
+# output window for display
+w

src/examples/minimal.jl

@@ -0,0 +1,13 @@
+using ControlSystems, GtkInteract, Immerse
+
+k = slider(1:0.1:10)
+
+cg1 = cairographic(width=200,height=150);
+
+w = window(vbox(k,grow(cg1)))
+
+Reactive.preserve(map(k) do k
+  fig1 = Immerse.plot(y=(1:10).^k)
+  push!(cg1, fig1)
+end)
+w

src/framework.jl

@@ -0,0 +1,62 @@
+null_theme = Theme(
+              minor_label_font_size=0pt, #Size of ticks
+              major_label_font_size=0pt, #Size of axis text
+              line_width=0pt, #Plot line
+              panel_fill=Colors.RGB(.95,.95,.95),
+              background_color=Colors.RGB(.95,.95,.95)
+              )
+default_theme = Theme(
+              minor_label_font_size=16pt, #Size of ticks
+              major_label_font_size=26pt, #Size of axis text
+              line_width=5pt, #Plot line
+              panel_fill=Colors.RGB(.99,.99,.99),
+              background_color=Colors.RGB(.99,.99,.99)
+              )
+
+#Almost empty plot
+na_plot = Immerse.plot(x=[0.0], y=[0.0], Geom.line, null_theme)
+
+function Base.push!(obj::GtkInteract.CairoGraphic, p::Void)
+    push!(obj, na_plot)
+end
+
+function Base.push!(obj::GtkInteract.CairoGraphic, p::Gadfly.Plot)
+    if obj.obj != nothing
+      push!(obj.obj, p)
+    end
+end
+
+function get_log_ticks(x)
+    min = ceil(log10(minimum(x)))
+    max = floor(log10(maximum(x)))
+    major = 10.^collect(min:max)
+    majorText = ["\$10^{$(round(Int64,i))}\$" for i=min:max]
+    if length(major) < 7
+      minor = [j*10^i for i=(min-1):(max+1) for j=2:9]
+      minor = minor[find(minimum(x) .<= minor .<= maximum(x))]
+    else
+      minor = Float64[]
+    end
+    if length(major) < 2
+      minorText = ["\$j*10^\{$i\}\$" for i=(min-1):(max+1) for j=2:9]
+    else
+      minorText = fill("", length(minor))
+    end
+    major, minor, majorText, minorText
+end
+
+function labelf(x)
+  if abs(round(Int64, x) - x) < 1e-5
+    @sprintf("10<sup>%1.0f</sup>", x)
+  else
+    ""
+  end
+end
+
+function major_lines(x, y, xticks, yticks)
+  layer(
+    x=x, y=y,
+    yintercept=yticks, xintercept=xticks, Geom.nil,
+    Geom.hline, Geom.vline, Theme(line_width=0.2pt, default_color=Colors.RGB(.1,.1,.1))
+  )
+end

src/plots.jl

@@ -0,0 +1,87 @@
+function bode_immerse(sys, w, ymin, ymax)
+  mag, phase, _ = bode(sys, w)
+  I = find(y-> ymin .<= y .<= ymax, mag) # Filter out from range
+  mag = mag[I]
+  ws = w[I]
+  xmajor, xminor, xmajorText, xminorText = get_log_ticks(w)
+  ymajor, yminor, ymajorText, yminorText = get_log_ticks([ymin;mag;ymax])
+  Immerse.plot(
+        major_lines(log10(ws), log10(mag), log10(xmajor), log10(ymajor)),
+        layer(x=log10(ws), y=log10(mag), Geom.line),
+        Stat.xticks(ticks = log10([xmajor;xminor])),
+        Stat.yticks(ticks = log10([ymajor;yminor])),
+        Scale.x_continuous(labels= x -> labelf(x), maxvalue=log10(maximum(w))),
+        Scale.y_continuous(labels= x -> labelf(x), minvalue=log10(ymin), maxvalue=log10(ymax)),
+        Guide.xlabel("Frequency (rad/s)"),
+        Guide.ylabel("Magnitude (abs)", orientation=:vertical),
+        default_theme)
+end
+function nyquist_immerse(sys, w, xmin, xmax, ymin, ymax)
+  re, im, _ = nyquist(sys, w)
+  I = (ymin .<= im .<= ymax) & (xmin .<= re .<= xmax)
+  re = re[I]
+  im = im[I]
+  Immerse.plot(
+        major_lines(re, im, [0.0], [0.0]),
+        layer(x=[-1], y=[0], Geom.point, Theme(default_color=Colors.RGB(.8,.0,.0), default_point_size=5pt)),
+        layer(x=re, y = im, Geom.line(preserve_order=true)),
+        Scale.x_continuous(minvalue = xmin, maxvalue=xmax),
+        Scale.y_continuous(minvalue = ymin, maxvalue=ymax),
+        Guide.xlabel("Real"),
+        Guide.ylabel("Imaginary", orientation=:vertical),
+        default_theme)
+end
+
+function pzmap_immerse(sys, xmin, xmax, ymin, ymax)
+  z, p, k = zpkdata(sys)
+  z = z[1]; p = p[1];
+  I(x) = (ymin .<= imag(x) .<= ymax) & (xmin .<= real(x) .<= xmax)
+  zx = real(z[I(z)])
+  zy = imag(z[I(z)])
+  px = real(p[I(p)])
+  py = imag(p[I(p)])
+  shapes = xcross(px, py, fill(3mm,length(px)))
+  theme = copy(default_theme)
+  theme.default_color = Colors.RGB(0,0,1)
+  theme.default_point_size = 6pt
+  Immerse.plot(
+        layer(x=zx, y=zy, Geom.point),
+        x = px,
+        y = py,
+        Scale.x_continuous(minvalue = xmin, maxvalue=xmax),
+        Scale.y_continuous(minvalue = ymin, maxvalue=ymax),
+        Guide.xlabel("Real"),
+        Guide.ylabel("Imaginary", orientation=:vertical),
+        theme,
+        Guide.annotation(Compose.compose!(Compose.context(), Gadfly.fill(Colors.RGB(1,0,0)), shapes)))
+end
+
+function timeplot_immerse(t, y, ymin, ymax)
+  Immerse.plot(
+        x = t,
+        y = y,
+        Scale.y_continuous(minvalue = ymin, maxvalue=ymax),
+        Guide.xlabel("Time"),
+        Guide.ylabel("Output", orientation=:vertical),
+        default_theme,
+        Geom.line)
+end
+
+function xcross(xs::AbstractArray, ys::AbstractArray, rs::AbstractArray)
+  n = max(length(xs), length(ys), length(rs))
+  polys = Vector{Vector{Tuple{Measures.Measure, Measures.Measure}}}(n)
+  s = 1/sqrt(5)
+  for i in 1:n
+    x = Compose.x_measure(xs[i])
+    y = Compose.y_measure(ys[i])
+    r = rs[i]
+    u = s*r
+    polys[i] = Tuple{Measures.Measure, Measures.Measure}[
+      (x, y - u), (x + u, y - 2u), (x + 2u, y - u),
+      (x + u, y), (x + 2u, y + u), (x + u, y + 2u),
+      (x, y + u), (x - u, y + 2u), (x - 2u, y + u),
+      (x - u, y), (x - 2u, y - u), (x - u, y - 2u)
+    ]
+  end
+  return Gadfly.polygon(polys)
+end