cleaning up

Author: SimonDanisch

docs/new/3dlines.png

@@ -0,0 +1,35 @@
+using GLAbstraction, Colors, Images
+# The number of points per line
+N = 300
+
+# The scalar parameter for each line
+TL = linspace(-2f0 * pi, 2f0 * pi, N)
+
+# We create a list of positions and connections, each describing a line.
+# We will collapse them in one array before plotting.
+xyz         = Point3f0[]
+s           = RGBA{Float32}[]
+
+# The index of the current point in the total amount of points
+nloops = 50
+base_colors1 = distinguishable_colors(nloops, RGB{Float64}(1,0,0))
+base_colors2 = distinguishable_colors(nloops, RGB{Float64}(1,1,0))
+# Create each line one after the other in a loop
+for i=1:nloops
+    append!(xyz, [Point3f0(sin(t), cos((2 + .02 * i) * t), cos((3 + .02 * i) * t)) for t in TL])
+    unique_colors = base_colors1[i]
+    hsv = HSV(unique_colors)
+    println(hsv, " ", unique_colors)
+    a = sequential_palette(hsv.h, N, s=hsv.s)
+    color_palette = map(x->RGBA{Float32}(x, 1.0), a)
+    append!(s, color_palette)
+end
+
+using GLVisualize, Reactive
+w, r = glscreen()
+buff = GLBuffer(s)
+x = map(p->p[1], xyz)
+y = map(p->p[2], xyz)
+z = map(p->p[3], xyz)
+view(visualize(x,y,z, :surface), method=:perspective)
+r()

docs/new/surface_mesh.png

@@ -0,0 +1,91 @@
+using GeometryTypes, Quaternions, GLVisualize, Reactive, GLAbstraction
+function quaternion_belt_trick()
+
+    rad1 = 1f0 # outer circle
+    rad2 = 0.2f0 # inner circle
+
+    center1 = Point(rad1,rad1) # left
+    center2 = Point(rad1+2f0,rad1) # right
+
+    u1234 = Quaternion(0.,0.,1.,0.) # gets rotated
+    axis  = Quaternion(0.,0.,0.,1.) # axis of qrotationdd
+    mi  = 80
+    mj  = 10
+    rxs = zeros(Float32, mi+1,mj+1)
+    rys = zeros(Float32, mi+1,mj+1)
+    rzs = zeros(Float32, mi+1,mj+1)
+
+    max_frames = 96
+    dphi = 2*pi/(max_frames-1) # include both ends
+    w, r = glscreen()
+
+    u1234_s = foldp(u1234, bounce(1:max_frames)) do v0, _
+        qrotation(axis, v0, dphi)
+    end
+    xyz = const_lift(plot_belts, rxs, rys, rzs, u1234_s, center1, center2, rad1, rad2)
+    x = const_lift(getindex, xyz, 1)
+    view(visualize(
+       x, const_lift(getindex, xyz, 2), const_lift(getindex, xyz, 3), :surface
+    ))
+
+    r()
+end
+
+
+#------------------------------------
+
+function plot_circles(center1, center2, rad1, rad2)
+    mi      = 100
+    iis     = 1:(mi+1)
+    thetas  = 2*pi*(iis-1)/mi
+    als     = cos(thetas)
+    bls     = sin(thetas)
+
+    for ii=2:(mi+1)
+        #plot(center1[1]+rad1*[als[ii-1],als[ii]],center1[2]+rad1*[bls[ii-1],bls[ii]]) # left one
+        #plot(center1[1]+rad2*[als[ii-1],als[ii]],center1[2]+rad2*[bls[ii-1],bls[ii]])
+        #plot(center2[1]+rad1*[als[ii-1],als[ii]],center2[2]+rad1*[bls[ii-1],bls[ii]]) # right one
+        #plot(center2[1]+rad2*[als[ii-1],als[ii]],center2[2]+rad2*[bls[ii-1],bls[ii]])
+    end
+end
+#------------------------------------
+
+function plot_belts(rxs, rys, rzs, u1234, center1, center2, rad1, rad2)
+    mi  = 80
+    mj  = 10
+    iis = 1:(mi+1)
+    rs  = rad1-((rad1-rad2)*(iis-1)/mi)
+    for ii=1:(mi+1)
+        jjs   = 1:(mj+1)
+        xs    = (rad2/mj)*((jjs-1)-(mj/2))
+        ys    = sqrt(rs[ii]*rs[ii]-xs.*xs)
+        theta = 2*pi*(ii-1)/mi
+
+        for jj=1:(mj+1)
+            efgh    = Quaternion(0., xs[jj], ys[jj], 0.)
+            wxyz    = qrotation(efgh, u1234, theta)
+            rxs[ii,jj] = center1[1]+wxyz.v1
+            rys[ii,jj] = center1[2]+wxyz.v2
+            rzs[ii,jj] = wxyz.v3
+        end
+        #plot1(rxs-0.1*rzs, +rys, rzs, center1[1], center1[2], rad2) # left one
+        #plot1(center2[1]+rxs+0.1*rzs, center2[2]+rys, rzs, center2[1], center2[2], rad2) # right one
+    end
+    rxs, rys, rzs
+end
+
+#------------------------------------
+
+function plot1(sxs, sys, szs, xc, yc, rad2)
+    hidz = (szs<0)
+    txs  = sxs-xc
+    tys  = sys-yc
+    hidr = (((txs.*txs)+(tys.*tys))<(rad2*rad2))
+    hid  = hidr&hidz
+    sxs[hid] = NaN
+    sys[hid] = NaN
+    #plot(sxs,sys) # left one
+end
+quaternion_belt_trick()
+
+#------------------------------------

examples/3dlines.jl

@@ -2,8 +2,9 @@ using FileIO, Images, GLVisualize, Reactive, ColorTypes, GLAbstraction, Geometry
 
 w, r = glscreen()
 slider_s, slider = vizzedit(1f0:0.1f0:20f0, w.inputs)
-
-img = restrict(map(RGBA{Float32}, load(joinpath(homedir(), "julia.png"))))
+# if link is broken, you can just use any path to an arbitrary file on your disk
+julia_logo = download("https://camo.githubusercontent.com/e1ae5c7f6fe275a50134d5889a68f0acdd09ada8/687474703a2f2f6a756c69616c616e672e6f72672f696d616765732f6c6f676f5f68697265732e706e67")
+img = restrict(map(RGBA{Float32}, load(julia_logo)))
 
 function myfilter(img, sigma)
 	img = imfilter_gaussian(img, [sigma, sigma])

examples/dirac_belt.jl

@@ -0,0 +1,21 @@
+# Calculate the Julia set on a grid
+x = [Float32(i)*im for i=-1.5:0.5:500]
+y = [Float32(i)*im for i=-1:1:500]
+println(size(x))
+println(size(y))
+z = x + 1im * y
+
+julia = zeros(Float32, size(z))
+
+for i=1:50
+    z = z^2 - 0.70176 - 0.3842im
+    julia += 1 / 2f0 + i) * (z * conj(z) > 4)
+end
+
+# Display it
+view(visualize(julia))
+
+# A view into the "Canyon"
+view(65, 27, 322, [30., -13.7,  136])
+show()
+

examples/image_processing.jl

@@ -0,0 +1,22 @@
+# taken from http://docs.enthought.com/mayavi/mayavi/auto/mlab_helper_functions.html#mayavi.mlab.mesh
+dphi, dtheta = pi/250.0f0, pi/250.0f0
+function mgrid(dim1, dim2)
+    X = [i for i in dim1, j in dim2]
+    Y = [j for i in dim1, j in dim2]
+    return X,Y
+end
+phi,theta = mgrid(0f0:dphi:(pi+dphi*1.5f0), 0f0:dtheta:(2f0*pi+dtheta*1.5f0))
+m0 = 4f0; m1 = 3f0; m2 = 2f0; m3 = 3f0; m4 = 6f0; m5 = 2f0; m6 = 6f0; m7 = 4f0;
+a = sin(m0*phi).^m1
+b = cos(m2*phi).^m3
+c = sin(m4*theta).^m5
+d = cos(m6*theta).^m7
+r = a + b + c + d
+x = r.*sin(phi).*cos(theta)
+y = r.*cos(phi)
+z = r.*sin(phi).*sin(theta)
+
+using GLVisualize, GLAbstraction
+w,r = glscreen()
+view(visualize(x,y,z, :surface))
+r()

examples/juliaset.jl

@@ -1,6 +1,6 @@
 {{GLSL_VERSION}}
 
-in vec2 vertex;
+{{vertex_type}} vertex;
 in float lastlen;
 //in float thickness;
 {{color_type}} color;
@@ -16,12 +16,15 @@ out float g_thickness;
 vec4 getindex(sampler2D tex, int index);
 vec4 getindex(sampler1D tex, int index);
 
+vec4 to_vec4(vec3 v){return vec4(v, 1);}
+vec4 to_vec4(vec2 v){return vec4(v, 0, 1);}
+
 void main()
 {
 	g_lastlen 	= lastlen;
 	int index 	= gl_VertexID;
 	g_id 		= uvec2(objectid, index+1);
 	//g_thickness = thickness;
 	g_color 	= {{color_calculation}};
-	gl_Position = projectionview*model*vec4(vertex, 0, 1);
+	gl_Position = projectionview*model*to_vec4(vertex);
 }

examples/mesh.jl

@@ -1,4 +1,4 @@
-visualize_default{T <: Real}(::Union{Texture{Point{2, T}, 1}, Vector{Point{2, T}}}, s::Style{:lines}, kw_args=Dict()) = Dict(
+visualize_default{T <: Real, N}(::Union{Texture{Point{N, T}, 1}, Vector{Point{N, T}}}, s::Style{:lines}, kw_args=Dict()) = Dict(
     :shape               => RECTANGLE,
     :style               => FILLED,
     :transparent_picking => false,
@@ -8,7 +8,7 @@ visualize_default{T <: Real}(::Union{Texture{Point{2, T}, 1}, Vector{Point{2, T}
     :dotted              => false
 )
 
-function visualize(locations::Signal{Vector{Point{2, Float32}}}, s::Style{:lines}, customizations=visualize_default(locations.value,s))
+function visualize{N}(locations::Signal{Vector{Point{N, Float32}}}, s::Style{:lines}, customizations=visualize_default(locations.value,s))
     ll = const_lift(lastlen, locations)
     maxlength = const_lift(last, ll)
 
@@ -27,15 +27,15 @@ function lastlen(points)
     end
     result
 end
-function visualize{T}(positions::GLBuffer{Point{2, T}}, ll::GLBuffer{T}, maxlength, s::Style{:lines}, data=visualize_default(positions,s))
+function visualize{T <: Point, FT <: AbstractFloat}(positions::GLBuffer{T}, ll::GLBuffer{FT}, maxlength, s::Style{:lines}, data=visualize_default(positions,s))
     ps = gpu_data(positions)
     data[:vertex]    = positions
     data[:lastlen]   = ll
     data[:maxlength] = maxlength
     data[:max_primitives] = Cint(length(positions)-4)
 
     program = GLVisualizeShader("util.vert", "lines.vert", "lines.geom", "lines.frag", attributes=data)
-    std_renderobject( 
+    std_renderobject(
         data, program,
         Input(AABB{Float32}(ps)), GL_LINE_STRIP_ADJACENCY 
     )

src/shader/lines.vert

@@ -56,4 +56,4 @@ view(c::Composable, screen=ROOT_SCREEN; kw_args...) = view(extract_renderable(c)
 
 default{T}(::T, s::Style) = default(T, s)
 default{T <: Colorant}(::Type{T}, s::Style) = RGBA{Float32}(0.78, 0.01, 0.93, 1.0)
-default{T <: Colorant}(::Type{Vector{T}}, s::Style) = map(x->RGBA{U8}(x, 1.0), colormap("Blues"))
+default{T <: Colorant}(::Type{Vector{T}}, s::Style) = map(x->RGBA{U8}(x, 1.0), colormap("Blues", 20))