# Rheotomic Surface, how?

Hello,

i got hypnotized by these forms? is there anything to built up this in dynamo ? or placing families based on that KR

Andreas

1 Like

Hi, you looked on the site (there is his address on his file) of Mr. Vikram
Mr. Marcel must have leads too I think, he seems a fan of geometric objects

cordially
christian.stan

2 Likes

so i “awake” them to this topic @Vikram_Subbaiah @Marcel_Rijsmus

2 Likes

Let me sleep on it No ,seriously i’ve moved onwards since.
Maybe @Vikram_Subbaiah can be of assistance

3 Likes

Here is a surface I don’t know if it comes within the prerogatives, you can add a little movement to the cylinder

23 janvier funny Draxl.dyn (29.1 KB)

cordially
christian.stan

1 Like

Not Rheotomic, but this thread has similar things 2 Likes

Hi @Draxl_Andreas you could have a look at this grasshopper script if you have access to rhino:

If you have, but haven’t worked with grasshoppoer yet: It’s quite similar to dynamo and you should have no problem in analysing how the script works.

Here is a demo video of the author using his script:

2 Likes

it is fake but funny … i found something to the Dyole function

thats exposed to the grasshopper graph as pythoncode…

``````#Seghier Mohamed Abdelaziz - 2021

import Rhino.Geometry as rg
import ghpythonlib.components as ghc
import math

pow = math.pow
sin = math.sin
cos = math.cos
pi = math.pi
sqrt = math.sqrt
q = p*n

def prop(z,t,p,q):
w = pow(z,p/q)
s = (p*t+2*pi)/q
v = [w,s]
return v

def _d(z,t,p,q):
w = pow(z,p/q)
s = (p*t+2*pi)/q
v = pow(z*cos(t)-w*cos(s),2)+pow(z*sin(t)-w*sin(s),2)
return v

def ddz_d(z,t,p,q):
w = pow(z,p/q)
s = (p*t+2*pi)/q
ddz_w = (p/q)*pow(z,(p-q)/q)
v = 2*(w*cos(s) - z*cos(t))*(ddz_w*cos(s) - cos(t))+ 2*(w*sin(s) - z*sin(t))*(ddz_w*sin(s) - sin(t))
return v

def ddt_d(z,t, p,q):
w = pow(z, p/q)
s = (p*t + 2*pi)/q
dds_t = (p/q)
v = 2*( z*cos(t) - w*cos(s) )*( -z*sin(t) + w*sin(s)*dds_t )+ 2*( z*sin(t) - w*sin(s) )*( z*cos(t) - w*cos(s)*dds_t )
return v

def _s(z,t, p,q):
v = pow(z + pow(z, p/q), 2)
return v

def ddz_s(z,t, p,q):
w = pow(z, p/q)
ddz_w = (p/q)*pow(z, (p-q)/q)
v = 2*(w+z)*(ddz_w+1)
return v

def _r(z,t, p,q):
v = _d(z,t,p,q) / _s(z,t,p,q)
return v

def ddz_r(z,t, p,q):
v = (ddz_d(z,t,p,q) * _s(z,t,p,q) - _d(z,t,p,q) * ddz_s(z,t,p,q)) / pow( _s(z,t,p,q), 2 )
return v

def ddt_r(z,t, p,q):
v = (ddt_d(z,t,p,q) * _s(z,t,p,q)) / pow( _s(z,t,p,q), 2 )
return v

#-------------------------------------------------------
def _f(z, t):
return _r(z,t,0,1) - _r(z,t,p,q)

def ddz_f(z, t):
return ddz_r(z,t,0,1) - ddz_r(z,t,p,q)

def ddt_f(z, t):
return ddt_r(z,t,0,1) - ddt_r(z,t,p,q)

def _g(z, t):
return _r(z,t,0,1) - _r(pow(z, p/q), (p*t + 2*pi)/q, 0 ,1)

def ddz_g(z, t):
return ddz_r(z,t,0,1) - ddz_r(pow(z, p/q), (p*t + 2*pi)/q, 0,1) * (p/q)*pow(z, (p-q)/q)

def ddt_g(z, t):
return ddt_r(z,t,0,1) - ddt_r(pow(z, p/q), (p*t + 2*pi)/q, 0,1) * (p/q)
#-------------------------------------------------------
class doyle:
def find_root(z, t):
for i in range(100):
v_f = _f(z, t)
v_g = _g(z, t)
z= z; t= t; r= sqrt(_r(z,t,0,1))
a = ddz_f(z,t)
b = ddt_f(z,t)
c = ddz_g(z,t)
d = ddt_g(z,t)
det = a*d-b*c
z -= (d*v_f - b*v_g)/det
t -= (a*v_g - c*v_f)/det
return z,t,r

root = find_root(2,0)
z = root
t = root
r = root
a = [z * cos(t), z * sin(t) ]
_z = pow(z, p/q)
_t = (p*t+2*pi)/q
_r = 0.0
b = [_z * cos(_t), _z * sin(_t) ]

a= doyle.a; b= doyle.b; r=doyle.r; mod_a = z = doyle.z; t= doyle.t

def cmul(w,z):
v = [w*z - w*z,w*z + w*z]
return v
def modulus(p):
v = sqrt(p*p + p*p)
return v

def crecip(z):
d = pow(z,2)+pow(z,2)
v = [-z/d, z/d]
return v

circles = []
def Spiral(r, start_point, delta, min_d, max_d):
recip_delta = crecip(delta)
q = cmul(start_point, recip_delta)
mod_q = modulus(q)
circle = rg.Circle(rg.Plane.WorldXY, rg.Point3d(q, q, 0), mod_q*r)
q = cmul(q, recip_delta)
return circles

scale = pow(mod_a, -1)
min_d = scale
n = n-1
max_d = q*n
start = a
for i in range(max_d):
start = cmul(start, b)
Circles = Spiral(r, start, a, min_d, max_d)

def mobius(g,c,a,q,bool):
G = ghc.trees.Kangaroo2Component.MbiusTransformation(g,c,a,q,bool)
return G

G = ghc.trees.PolarArray(Circles,rg.Plane.WorldXY,p,2*pi)
if T == True:
G = ghc.trees.FlipMatrix(G)
C = ghc.Circle(rg.Plane.WorldXY,pi*C)
G = mobius(G,C,pi/2,Q,False)
G = ghc.trees.Rotate(G,pi/2,rg.Plane.WorldZX)
G = mobius(G,C,-pi/2,0,False)
R = ghc.trees.DeconstructArc(G)
P = ghc.trees.Evaluate('if(x>10,0,1)',R)
G = ghc.trees.CullPattern(G,P)
else:
G = ghc.trees.FlipMatrix(G)

``````

Doyle_Spiral_V01.dyn (96.2 KB)

6 Likes