thi.ng.morphogen.core — thi.ng/morphogen 0.2.0-SNAPSHOT

apply-recursively clj/s

(apply-recursively tree n path id)

Recursively injects tree into itself n times, starting at given child path. At each subsequent level, the original tree given is injected at index id of the :out child node vector. The initial path is simply given as a seq of indices and will be translated into an actual lookup path using the child-path fn.

BoxNode cljs

child-path clj/s

(child-path path)

Takes a seq of child indices and constructs a lookup path/vector for them by interleaving :out in the seq: (child-path [1 0 2]) => [:out 1 :out 0 :out 2]

circle-lattice-seg clj/s

(circle-lattice-seg n h wall)

classify-node-at clj/s

(classify-node-at op-tree cursor)

compute-tree-map clj/s

(compute-tree-map seed tree)

compute-tree-map* clj/s

(compute-tree-map* node tree acc path)

execute-op-tree clj/s

(execute-op-tree leaf-fn acc node tree max-depth)

extrude clj/s

(extrude & {:keys [dir len out empty?] :or {dir :n len 1.0}})

extrude-prop clj/s

(extrude-prop & {:keys [dir len out empty?] :or {dir :n len 1.0}})

face-opposite clj/s

generate-mesh clj/s

(generate-mesh seed tree)

(generate-mesh seed tree max-depth)

inject clj/s

(inject t path t')

Almost like assoc-in, but transforms lookup path with child-path.

INode clj/s≠ protocol

parent clj/s

(parent _)

Returns the node's parent or nil if node is the root

with-operator-node clj/s

(with-operator-node _ op)

Returns same node with new operator node attached

face-vertices clj/s

(face-vertices _ face)

Returns vertices for given face ID

tree-depth clj/s

(tree-depth _)

Returns the node's tree depth

operator-node clj/s

(operator-node _)

Returns related node from operator tree

face-topology clj/s

(face-topology _)

Returns number of vertices used for each face in the node

make-planar clj/s

(make-planar a b c d)

map-leaves clj/s

(map-leaves f tree)

(map-leaves f tree depth)

Takes a fn and operator tree, applies f to all leaf nodes. The fn must accept 3 args: the leaf's parent node, the child index of the leaf in the parent and the tree depth. The leaf will be replaced with the fn's return value.

offset-face-points clj/s

(offset-face-points [a b c d e f g h] side n)

op-tree-depth clj/s

(op-tree-depth tree)

operator clj/s

operator-output clj/s

(operator-output n out empty?)

operator-seq clj/s

(operator-seq node)

operator-seq-no-leaves clj/s

(operator-seq-no-leaves node)

quad-normal clj/s

(quad-normal [a b c d])

(quad-normal a b c d)

Takes 4 points (or a seq of 4 points), returns vector perdendicular to the 2 diagonals of the quad

reflect clj/s

(reflect dir & {:keys [out empty?] :or {dir :n}})

reflect-on-plane clj/s

(reflect-on-plane p q n)

Reflects point p on plane defined by point q & normal n. Normal vector must be normalized.

reflect-seq clj/s

(reflect-seq dirs & [leaf])

Takes a seq of direction keys and optional leaf tree. Builds a tree encoding a nested reflection sequence in the order given. If leaf is specified, injects it at the end of the nested reflection.

replicate clj/s

(replicate dir & {:keys [out empty?]})

save-obj-mesh clj

(save-obj-mesh seed tree)

(save-obj-mesh seed tree path)

(save-obj-mesh seed tree path max-depth)

save-ply-mesh clj

(save-ply-mesh seed tree)

(save-ply-mesh seed tree path)

(save-ply-mesh seed tree path max-depth)

save-stl-mesh clj

(save-stl-mesh seed tree)

(save-stl-mesh seed tree path)

(save-stl-mesh seed tree path max-depth)

scale-edge clj/s

(scale-edge edge sym & {:keys [scale len out] :or {scale 0.5}})

seed-box clj/s

(seed-box x)

skew clj/s

(skew side ref & {:keys [offset out] :or {offset 0.25}})

sphere-lat clj/s

(sphere-lat resu resv wall)

sphere-lattice-seg clj/s

(sphere-lattice-seg n h inset wall)

split-displace clj/s

(split-displace dir ref & {:keys [offset out] :or {offset 0.25}})

subdiv clj/s

(subdiv &
        {:keys [cols rows slices num out empty?] :or {cols 1 rows 1 slices 1}})

subdiv-inset clj/s

(subdiv-inset & {:keys [dir inset out empty?] :or {dir :y inset 0.25}})

subdivide-inset clj/s

(subdivide-inset [a b c d e f g h :as points]
                 {i :inset dir :dir :or {i 0.1 dir :y}})

subdivide-inset___ clj/s

(subdivide-inset___ [a b c d e f g h :as points]
                    {i :inset dir :dir :or {i 0.1 dir :y}})

union-mesh clj/s

(union-mesh meshes)

(union-mesh target eps meshes)

walk-op-tree clj/s

(walk-op-tree f acc node depth)