def __init__(self):
self.particles = []
self.targetID = r'8d8dd842-3d3f-4f65-b7d4-e4089e4f9cbb'
self.target = rs.coercemesh(self.targetID)
self.boundary = rg.Box(rg.Plane.WorldXY, rg.Interval(0, 100),
rg.Interval(0, 100), rg.Interval(0, 100))
self.boundary = self.boundary.ToBrep()
self.time = 0
self.attr = rc.DocObjects.ObjectAttributes()
self.attr.ColorSource = rc.DocObjects.ObjectColorSource.ColorFromObject
self.attr.MaterialSource = rc.DocObjects.ObjectMaterialSource.MaterialFromObject
grad = color.GetGradient(1)
self.attr.ObjectColor = color.GradientOfColors(grad, 0)
self.attr.ObjectColor = drawing.Color.White
index = sc.doc.Materials.Add()
self.mat = sc.doc.Materials[index]
self.mat.DiffuseColor = self.attr.ObjectColor
self.mat.CommitChanges()
self.attr.MaterialIndex = index
self.attr = rc.DocObjects.ObjectAttributes()
self.attr.ColorSource = rc.DocObjects.ObjectColorSource.ColorFromObject
self.attr.MaterialSource = rc.DocObjects.ObjectMaterialSource.MaterialFromObject
#ATTR1
self.attr1 = rc.DocObjects.ObjectAttributes()
self.attr1.ColorSource = rc.DocObjects.ObjectColorSource.ColorFromObject
self.attr1.MaterialSource = rc.DocObjects.ObjectMaterialSource.MaterialFromObject
self.attr1.ObjectColor = drawing.Color.Green
index = sc.doc.Materials.Add()
mat1 = sc.doc.Materials[index]
mat1.DiffuseColor = self.attr1.ObjectColor
mat1.CommitChanges()
self.attr1.MaterialIndex = index
#ATTR2
self.attr2 = rc.DocObjects.ObjectAttributes()
self.attr2.ColorSource = rc.DocObjects.ObjectColorSource.ColorFromObject
self.attr2.MaterialSource = rc.DocObjects.ObjectMaterialSource.MaterialFromObject
self.attr2.ObjectColor = drawing.Color.Blue
index = sc.doc.Materials.Add()
mat2 = sc.doc.Materials[index]
mat2.DiffuseColor = self.attr2.ObjectColor
mat2.CommitChanges()
self.attr2.MaterialIndex = index
self.clays = []
#numClays = 1
#for i in range(numClays):
# self.clays.append(Clay(self, color.GradientOfColors(grad, i/numClays), rg.Interval(25+(i*10), 35+(i*10))))
numClays = 1
self.clays.append(
Clay(self, color.GradientOfColors(grad, 0), rg.Interval(35, 65)))
self.particles = []
for i in range(6):
self.particles.append(Particle(self))
def __init__(self):
self.particles = []
self.boundary = rg.Box(rg.Plane.WorldXY, rg.Interval(0, 100),
rg.Interval(0, 100), rg.Interval(0, 100))
self.boundary = self.boundary.ToBrep()
self.time = 0
self.attr = rc.DocObjects.ObjectAttributes()
self.attr.ColorSource = rc.DocObjects.ObjectColorSource.ColorFromObject
self.attr.MaterialSource = rc.DocObjects.ObjectMaterialSource.MaterialFromObject
grad = color.GetGradient(5)
self.attr.ObjectColor = color.GradientOfColors(grad, 0)
self.attr.ObjectColor = drawing.Color.White
index = sc.doc.Materials.Add()
self.mat = sc.doc.Materials[index]
self.mat.DiffuseColor = self.attr.ObjectColor
self.mat.CommitChanges()
self.attr.MaterialIndex = index
self.attr = rc.DocObjects.ObjectAttributes()
self.attr.ColorSource = rc.DocObjects.ObjectColorSource.ColorFromObject
self.attr.MaterialSource = rc.DocObjects.ObjectMaterialSource.MaterialFromObject
self.attr0 = self.attr.Duplicate()
self.attr0.ObjectColor = color.GradientOfColors(grad, .5)
index = sc.doc.Materials.Add()
self.mat0 = sc.doc.Materials[index]
self.mat0.DiffuseColor = self.attr0.ObjectColor
self.mat0.CommitChanges()
self.attr0.MaterialIndex = index
self.attr1 = self.attr.Duplicate()
self.attr1.ObjectColor = color.GradientOfColors(grad, 0)
index = sc.doc.Materials.Add()
self.mat1 = sc.doc.Materials[index]
self.mat1.DiffuseColor = self.attr1.ObjectColor
self.mat1.CommitChanges()
self.attr1.MaterialIndex = index
self.attr2 = self.attr.Duplicate()
self.attr2.ObjectColor = color.GradientOfColors(grad, 1)
index = sc.doc.Materials.Add()
self.mat2 = sc.doc.Materials[index]
self.mat2.DiffuseColor = self.attr2.ObjectColor
self.mat2.CommitChanges()
self.attr2.MaterialIndex = index
self.clay0 = Clay(self, self.attr0, rg.Interval(35, 40))
self.clay1 = Clay(self, self.attr1, rg.Interval(30, 35))
self.clay2 = Clay(self, self.attr2, rg.Interval(40, 55))
self.balls = []
for i in range(5):
self.balls.append(Ball(self))
def __init__(self, system):
self.system = system
self.val = None
self.history = []
self.historyPos = []
self.pipeIDs = []
self.pipe = None
self.pipes = []
self.alive = True
self.length = 4
self.turned = False
self.prevVel = None
self.prevPlane = None
self.majorBrep = rg.Brep()
self.cases = {
0: rg.Vector3d(1,0,0),
1: rg.Vector3d(-1,0,0),
2: rg.Vector3d(0,1,0),
3: rg.Vector3d(0,-1,0),
4: rg.Vector3d(0,0,1),
5: rg.Vector3d(0,0,-1)
}
self.case = random.randint(0,len(self.cases)-1)
#Movement
self.vel = rg.Vector3d(random.uniform(-1,1),random.uniform(-1,1), random.uniform(-.2,.2))
self.vel.Unitize()
self.tempVel = self.vel.Clone()
self.speed = self.length
self.vel *= self.speed
self.acc = rg.Vector3d(0,0,0)
self.size = 1
self.cone = None
self.coneID = None
self.rotAngle = 0
#Color and Material
self.attr = rc.DocObjects.ObjectAttributes()
self.attr.ColorSource = rc.DocObjects.ObjectColorSource.ColorFromObject
self.grad = color.GetGradient(random.randint(0,9))
#col = drawing.Color.AliceBlue
self.attr.MaterialSource = rc.DocObjects.ObjectMaterialSource.MaterialFromObject
self.attr.ObjectColor = color.GradientOfColors(self.grad, 0)
index = sc.doc.Materials.Add()
self.mat = sc.doc.Materials[index]
self.mat.DiffuseColor = self.attr.ObjectColor
self.mat.CommitChanges()
self.attr.MaterialIndex = index
#Position
self.pos = rg.Point3d(random.uniform(5,95), random.uniform(5,95), random.uniform(5,95))
#self.pos = rg.Point3d(50, 50, 50)
self.plane = rg.Plane(self.pos, self.vel)
#Bake
self.tempIDs = []
self.ids = []
self.coneIDs = []
def UpdateDisplay(self):
if self.id: sc.doc.Objects.Delete(self.id, True)
if len(self.interPts) >= 3:
r, plane = rg.Plane.FitPlaneToPoints(self.interPts)
if r == rg.PlaneFitResult.Success:
us = []
vs = []
for eachPt in self.interPts:
r, u, v = plane.ClosestParameter(eachPt)
us.append(u)
vs.append(v)
uInt = rg.Interval(min(us), max(us))
vInt = rg.Interval(min(vs), max(vs))
planeSurface = rg.PlaneSurface(plane, uInt, vInt)
self.id = sc.doc.Objects.AddBrep(planeSurface.ToBrep())
if False:
if len(self.belowVertices) > 0 and len(self.belowVertices) < 8:
self.attr.ObjectColor = color.GradientOfColors(self.system.grad, util.Remap(len(self.belowVertices), 0, 8, 0, 1), 2)
index = sc.doc.Materials.Add()
mat = sc.doc.Materials[index]
mat.DiffuseColor = self.attr.ObjectColor
mat.CommitChanges()
self.attr.MaterialIndex = index
xform = rg.Transform.Scale(self.centerPt, util.Remap(len(self.belowVertices), 1, 7, .1, 1))
box = self.box.Duplicate()
box.Transform(xform)
self.id = sc.doc.Objects.AddMesh(box, self.attr)
def Update(self, time):
for id in self.ids:
if id:
sc.doc.Objects.Delete(id, True)
self.time = time
#################################
attr = self.attr.Duplicate()
grad = color.GetGradient(2)
col1 = color.GradientOfColors(grad, util.Remap(self.time, 0, 150, 0,
1))
attr.ObjectColor = col1
attr.ObjectColor = col1
index = sc.doc.Materials.Add()
self.mat = sc.doc.Materials[index]
self.mat.DiffuseColor = attr.ObjectColor
self.mat.CommitChanges()
attr.MaterialIndex = index
safety = 0
while True:
safety += 1
if safety > 20:
print "Safety"
break
newParticle = Particle(self, rg.Point3d(50, 50, 80), attr)
if newParticle.hit == False:
self.particles.append(newParticle)
break
for particle in self.particles:
particle.Update()
def __init__(self, system):
self.system = system
self.pos = rg.Point3d(random.uniform(10,90), random.uniform(10,90), random.uniform(10,90))
#self.vel = rg.Vector3d(random.uniform(-2, 2),random.uniform(-2, 2),random.uniform(-2, 2))
self.vel = rg.Vector3d(0,0,0)
self.vel.Unitize()
self.vel *= 5
self.acc = rg.Vector3d(0,0,0)
self.vel += self.acc
self.id = None
self.ids = []
self.age = 0
self.prevPlane = rg.Plane.WorldXY
self.xform = None
#Attr
self.attr = rc.DocObjects.ObjectAttributes()
self.attr.ColorSource = rc.DocObjects.ObjectColorSource.ColorFromObject
self.grad = color.GetGradient(10)
self.attr.ObjectColor = color.GradientOfColors(self.grad, 0)
self.attr.MaterialSource = rc.DocObjects.ObjectMaterialSource.MaterialFromObject
index = sc.doc.Materials.Add()
self.mat = sc.doc.Materials[index]
self.mat.DiffuseColor = self.attr.ObjectColor
self.mat.CommitChanges()
self.attr.MaterialIndex = index
self.InitTriangle()
def __init__(self):
self.particles = []
self.boundary = rg.Box(rg.Plane.WorldXY, rg.Interval(0, 100),
rg.Interval(0, 100), rg.Interval(0, 100))
self.boundary = self.boundary.ToBrep()
initPlane = rg.Plane.WorldXY
initPlane.Origin = rg.Point3d(50, 50, 50)
self.majorBrep = rg.Brep()
self.openPlanes = []
self.deadPlanes = []
self.nextRoundPlanes = [initPlane]
self.modules = []
self.size = 1
self.time = 0
self.attr = rc.DocObjects.ObjectAttributes()
self.attr.ColorSource = rc.DocObjects.ObjectColorSource.ColorFromObject
self.attr.MaterialSource = rc.DocObjects.ObjectMaterialSource.MaterialFromObject
grad = color.GetGradient(5)
self.attr.ObjectColor = color.GradientOfColors(grad, 0)
self.attr.ObjectColor = drawing.Color.White
index = sc.doc.Materials.Add()
self.mat = sc.doc.Materials[index]
self.mat.DiffuseColor = self.attr.ObjectColor
self.mat.CommitChanges()
self.attr.MaterialIndex = index
def __init__(self):
self.particles = []
self.boundary = rg.Box(rg.Plane.WorldXY, rg.Interval(-25, 125),
rg.Interval(-25, 125), rg.Interval(0, 100))
self.boundary = self.boundary.ToBrep()
self.time = 0
self.ids = []
self.attr = rc.DocObjects.ObjectAttributes()
self.attr.ColorSource = rc.DocObjects.ObjectColorSource.ColorFromObject
self.attr.MaterialSource = rc.DocObjects.ObjectMaterialSource.MaterialFromObject
grad = color.GetGradient(1)
self.attr.ObjectColor = color.GradientOfColors(grad, 0)
self.attr.ObjectColor = drawing.Color.White
index = sc.doc.Materials.Add()
self.mat = sc.doc.Materials[index]
self.mat.DiffuseColor = self.attr.ObjectColor
self.mat.CommitChanges()
self.attr.MaterialIndex = index
self.attr = rc.DocObjects.ObjectAttributes()
self.attr.ColorSource = rc.DocObjects.ObjectColorSource.ColorFromObject
self.attr.MaterialSource = rc.DocObjects.ObjectMaterialSource.MaterialFromObject
self.particles = []
#for i in range(2):
self.particles.append(Particle(self, rg.Point3d(25, 50, 80)))
self.particles.append(Particle(self, rg.Point3d(75, 50, 80)))
def UpdateDisplay(self):
self.attr.ObjectColor = color.GradientOfColors(self.grad, util.Remap(self.acc.Length, 0, .25, 0, 1))
index = sc.doc.Materials.Add()
self.mat = sc.doc.Materials[index]
self.mat.DiffuseColor = self.attr.ObjectColor
self.mat.CommitChanges()
self.attr.MaterialIndex = index
def __init__(self, system):
self.system = system
#self.pos = rg.Point3d(random.uniform(10,90), random.uniform(10,90), 90)
self.pos = rg.Point3d(50,50,95)
self.vel = rg.Vector3d(random.uniform(-2, 2),random.uniform(-2, 2),0)
#self.vel = rg.Vector3d(0,0,0)
self.acc = rg.Vector3d(0,0,-.5)
self.futureVel = None
self.ids = []
self.age = 0
self.width = random.uniform(1, 9)
self.depth = random.uniform(1, 9)
self.height = random.uniform(1, 9)
self.plane = rg.Plane.WorldXY
self.plane.Origin = self.pos
xSize = rg.Interval(-self.width/2, self.width/2)
ySize = rg.Interval(-self.depth/2, self.depth/2)
zSize = rg.Interval(-self.height/2, self.height/2)
self.box = rg.Box(self.plane, xSize, ySize, zSize)
self.boxBrep = self.box.ToBrep()
self.id = sc.doc.Objects.AddBrep(self.boxBrep)
self.vel += self.acc
self.futurePos = rg.Point3d.Add(self.pos, self.vel)
self.attr = rc.DocObjects.ObjectAttributes()
self.attr.ColorSource = rc.DocObjects.ObjectColorSource.ColorFromObject
grad = color.GetGradient(1)
self.attr.ObjectColor = color.GradientOfColors(grad, random.uniform(0,1))
self.attr.MaterialSource = rc.DocObjects.ObjectMaterialSource.MaterialFromObject
index = sc.doc.Materials.Add()
self.mat = sc.doc.Materials[index]
self.mat.DiffuseColor = self.attr.ObjectColor
self.mat.CommitChanges()
self.attr.MaterialIndex = index
self.primaryAxis = None
def Update2(self, time):
self.prevPlane = self.plane
self.attr.ObjectColor = color.GradientOfColors(self.grad, util.Remap(time, 0, 150, 0, 1))
index = sc.doc.Materials.Add()
self.mat = sc.doc.Materials[index]
self.mat.DiffuseColor = self.attr.ObjectColor
self.mat.CommitChanges()
self.attr.MaterialIndex = index
safety = 0
while True:
safety += 1
case = random.randint(1,2)
#case = 2
if case == 0:
#Straight
geo = self.system.straightSec.geo.Duplicate()
endPlane = self.system.straightSec.planeEnd.Clone()
xform = rg.Transform.PlaneToPlane(rg.Plane.WorldXY, self.prevPlane)
if case == 1:
#Angle
geo = self.system.angleSec.geo.Duplicate()
endPlane = self.system.angleSec.planeEnd.Clone()
self.prevPlane.Rotate(math.radians(random.uniform(0,360)), self.prevPlane.Normal, self.prevPlane.Origin)
xform = rg.Transform.PlaneToPlane(rg.Plane.WorldXY, self.prevPlane)
if case == 2:
#U Turn
geo = self.system.uTurnSec.geo.Duplicate()
endPlane = self.system.uTurnSec.planeEnd.Clone()
#rotForm = rg.Transform.Rotation(rg.Point3d(0,0,0))
#self.prevPlane.Transform(rotForm)
self.prevPlane.Rotate(math.radians(random.uniform(0,360)), self.prevPlane.Normal, self.prevPlane.Origin)
xform = rg.Transform.PlaneToPlane(rg.Plane.WorldXY, self.prevPlane)
geo.Transform(xform)
finished = False
results = rg.Intersect.Intersection.BrepBrep(geo, self.system.boundary, sc.doc.ModelAbsoluteTolerance)
if safety > 20:
print "SAFETY"
self.alive = False
break
if len(results[1]) == 0:
#results = rg.Intersect.Intersection.BrepBrep(geo, self.majorBrep, sc.doc.ModelAbsoluteTolerance)
#if len(results[1]) == 0:
# self.majorBrep.Append(geo)
# finished = True
#if finished:
break
endPlane.Transform(xform)
if self.alive:
sc.doc.Objects.AddBrep(geo, self.attr)
self.plane = endPlane
def __init__(self):
self.particles = []
self.boundary = rg.Box(rg.Plane.WorldXY, rg.Interval(0, 100),
rg.Interval(0, 100), rg.Interval(0, 100))
self.boundary = self.boundary.ToBrep()
initPlane = rg.Plane.WorldXY
initPlane.Origin = rg.Point3d(50, 50, 50)
self.majorBrep = rg.Brep()
self.breps = []
#self.pn = perlin.TileableNoise()
self.openPlanes = []
self.deadPlanes = []
self.nextRoundPlanes = [initPlane]
self.modules = []
self.time = 0
self.attr = rc.DocObjects.ObjectAttributes()
self.attr.ColorSource = rc.DocObjects.ObjectColorSource.ColorFromObject
self.attr.MaterialSource = rc.DocObjects.ObjectMaterialSource.MaterialFromObject
grad = color.GetGradient(5)
self.attr.ObjectColor = color.GradientOfColors(grad, 0)
self.attr.ObjectColor = drawing.Color.White
index = sc.doc.Materials.Add()
self.mat = sc.doc.Materials[index]
self.mat.DiffuseColor = self.attr.ObjectColor
self.mat.CommitChanges()
self.attr.MaterialIndex = index
self.balls = []
for i in range(10):
self.balls.append(Ball())
#self.ball = Ball()
self.voxels = []
self.size = 10
for i in range(0, 10):
for j in range(0, 10):
for k in range(0, 10):
s = 10
thisPlane = rg.Plane(
rg.Point3d(i * s + (s / 2), j * s + (s / 2),
k * s + (s / 2)), rg.Vector3d(0, 0, 1))
self.openPlanes.append(thisPlane)
for plane in self.openPlanes:
self.voxels.append(Module(self, self.size, plane))
for i in range(0):
self.voxels.append(Module(self, self.size, 0))
self.openPlanes += self.nextRoundPlanes
self.nextRoundPlanes = []
def UpdateDisplay(self):
sphere = rg.Sphere(self.system.mesh.Vertices[self.index], .8)
self.attr.ObjectColor = color.GradientOfColors(self.system.grad, util.Remap(self.d, 0, 30, 0, 1), 3)
index = sc.doc.Materials.Add()
mat = sc.doc.Materials[index]
mat.DiffuseColor = self.attr.ObjectColor
mat.CommitChanges()
self.attr.MaterialIndex = index
self.system.ids.append(sc.doc.Objects.AddSphere(sphere, self.attr))
def __init__(self, system, vec = None):
self.system = system
self.majorBrep = rg.Brep()
self.alive = True
self.age = 0
self.history = []
self.segments = []
#Movement
#self.vel = rg.Vector3d(random.uniform(-1,1),random.uniform(-1,1), random.uniform(-.2,.2))
#self.vel.Unitize()
#self.size = random.uniform(1, 3)
self.size = .1
self.length = .75
#Color and Material
self.attr = rc.DocObjects.ObjectAttributes()
self.attr.ColorSource = rc.DocObjects.ObjectColorSource.ColorFromObject
#self.grad = color.GetGradient(random.randint(0,9))
self.grad = color.GetGradient(4)
#col = drawing.Color.AliceBlue
col = color.GradientOfColors(self.grad, random.uniform(0,1))
self.attr.MaterialSource = rc.DocObjects.ObjectMaterialSource.MaterialFromObject
self.attr.ObjectColor = col
index = sc.doc.Materials.Add()
self.mat = sc.doc.Materials[index]
self.mat.DiffuseColor = self.attr.ObjectColor
self.mat.CommitChanges()
self.attr.MaterialIndex = index
#Position
self.pos = rg.Point3d(random.uniform(5,95), random.uniform(5,95), .1)
#self.pos = rg.Point3d(50, 50, 99)
self.dir = rg.Vector3d(0,0,1)
initPlane = rg.Plane.WorldXY
initPlane.Origin = self.pos
initPlane = rg.Plane(self.pos, self.dir)
self.openPlanes = []
self.planesToRemove = []
self.nextRoundPlanes = [initPlane]
self.crv = None
self.crvs = rc.Collections.CurveList()
self.pts = []
self.ids = []
sc.doc.Objects.AddSphere(rg.Sphere(self.pos, self.size), self.attr)
def __init__(self):
self.particles = []
self.boundary = rg.Box(rg.Plane.WorldXY, rg.Interval(0, 100),
rg.Interval(0, 100), rg.Interval(0, 100))
self.boundary = self.boundary.ToBrep()
self.time = 0
self.attr = rc.DocObjects.ObjectAttributes()
self.attr.ColorSource = rc.DocObjects.ObjectColorSource.ColorFromObject
self.attr.MaterialSource = rc.DocObjects.ObjectMaterialSource.MaterialFromObject
grad = color.GetGradient(1)
self.attr.ObjectColor = color.GradientOfColors(grad, 0)
self.attr.ObjectColor = drawing.Color.White
index = sc.doc.Materials.Add()
self.mat = sc.doc.Materials[index]
self.mat.DiffuseColor = self.attr.ObjectColor
self.mat.CommitChanges()
self.attr.MaterialIndex = index
self.attr = rc.DocObjects.ObjectAttributes()
self.attr.ColorSource = rc.DocObjects.ObjectColorSource.ColorFromObject
self.attr.MaterialSource = rc.DocObjects.ObjectMaterialSource.MaterialFromObject
self.clays = []
#numClays = 1
#for i in range(numClays):
# self.clays.append(Clay(self, color.GradientOfColors(grad, i/numClays), rg.Interval(25+(i*10), 35+(i*10))))
numClays = 1
self.clays.append(
Clay(self, color.GradientOfColors(grad, 0), rg.Interval(0, 30)))
self.balls = []
for i in range(4):
self.balls.append(Ball(self))
def __init__(self, system, x,y,z, xi, yi, zi):
self.system = system
self.pos = rg.Point3f(x,y,z)
self.xi = xi
self.yi = yi
self.zi = zi
sum = 0
for target in self.system.targets:
sum += target.radius/((target.pos - rg.Point3d(self.pos)).Length)
self.isoValue = sum
self.attr = self.system.attr.Duplicate()
self.attr.ObjectColor = color.GradientOfColors(self.system.grad, util.Remap(self.isoValue, .2, .8, 0, 1), 2)
def UpdateDisplay(self):
self.attr.ObjectColor = color.GradientOfColors(
self.grad, util.Remap(self.acc.Length, 0, .25, 0, 1))
index = sc.doc.Materials.Add()
self.mat = sc.doc.Materials[index]
self.mat.DiffuseColor = self.attr.ObjectColor
self.mat.CommitChanges()
self.attr.MaterialIndex = index
#for id in self.ids:
# sc.doc.Objects.Delete(id, True)
if self.id: sc.doc.Objects.Delete(self.id, True)
self.id = sc.doc.Objects.AddMesh(self.mesh, self.attr)
def UpdateDisplay(self):
self.attr.ObjectColor = color.GradientOfColors(self.grad, util.Remap(self.vel.Length, 3, 7, 0, 1))
index = sc.doc.Materials.Add()
self.mat = sc.doc.Materials[index]
self.mat.DiffuseColor = self.attr.ObjectColor
self.mat.CommitChanges()
self.attr.MaterialIndex = index
#if self.id: sc.doc.Objects.Delete(self.id, True)
for id in self.ids:
sc.doc.Objects.Delete(id, True)
if self.id is None:
self.id = sc.doc.Objects.AddMesh(self.mesh, self.attr)
else:
self.id = sc.doc.Objects.Transform(self.id, self.xform, True)
def __init__(self, targets, iv):
self.numVoxels = 25
self.voxelSize = 4
self.grad = color.GetGradient(10)
self.targets = []
self.isoValue = iv
self.mesh = rg.Mesh()
self.id = None
self.pts = []
self.ptsCollection = rc.Collections.Point3dList()
self.targets = targets
self.attr = rc.DocObjects.ObjectAttributes()
self.attr.ColorSource = rc.DocObjects.ObjectColorSource.ColorFromObject
grad = color.GetGradient(5)
self.attr.ObjectColor = color.GradientOfColors(
grad, util.Remap(self.isoValue, .3, .5, 0, 1), 3)
self.attr.MaterialSource = rc.DocObjects.ObjectMaterialSource.MaterialFromObject
index = sc.doc.Materials.Add()
mat = sc.doc.Materials[index]
mat.DiffuseColor = self.attr.ObjectColor
mat.CommitChanges()
self.attr.MaterialIndex = index
#Setup Vertices
self.vertices = []
for x in range(self.numVoxels + 1):
yRow = []
for y in range(self.numVoxels + 1):
zRow = []
for z in range(self.numVoxels + 1):
zRow.append(
Vertex(self, x * self.voxelSize, y * self.voxelSize,
z * self.voxelSize, x, y, z))
yRow.append(zRow)
self.vertices.append(yRow)
#Setup Voxels
self.voxels = []
index = 0
for x in range(self.numVoxels):
for y in range(self.numVoxels):
for z in range(self.numVoxels):
self.voxels.append(
Voxel(self, x * self.voxelSize, y * self.voxelSize,
z * self.voxelSize, x, y, z))
def UpdateDisplay(self):
if self.id: sc.doc.Objects.Delete(self.id, True)
if len(self.interPts) >= 3:
r, plane = rg.Plane.FitPlaneToPoints(self.interPts)
if r == rg.PlaneFitResult.Success:
if False:
v = plane.RemapToPlaneSpace(self.vertices[0].pos)[1]
if v.Z < 0 and self.vertices[
0].isoValue < self.system.isoValue:
#keep plane
pass
elif v.Z < 0 and self.vertices[
0].isoValue >= self.system.isoValue:
#flip plane
nRev = plane.Normal
nRev.Reverse()
plane = rg.Plane(plane.Origin, nRev)
elif v.Z >= 0 and self.vertices[
0].isoValue < self.system.isoValue:
#flip plane
nRev = plane.Normal
nRev.Reverse()
plane = rg.Plane(plane.Origin, nRev)
elif v.Z >= 0 and self.vertices[
0].isoValue >= self.system.isoValue:
#keep plane
pass
mesh = geo.DelaunayMesh(self.interPts, plane)
self.system.mesh.Append(mesh)
#self.id = sc.doc.Objects.AddMesh(mesh)
if False:
self.attr.ObjectColor = color.GradientOfColors(
self.system.grad,
util.Remap(len(self.belowVertices), 0, 8, 0, 1), 2)
index = sc.doc.Materials.Add()
mat = sc.doc.Materials[index]
mat.DiffuseColor = self.attr.ObjectColor
mat.CommitChanges()
self.attr.MaterialIndex = index
def __init__(self, system):
self.system = system
self.val = None
self.history = []
self.historyPos = []
self.pipeIDs = []
self.pipe = None
#Movement
self.vel = rg.Vector3d(random.uniform(-1, 1), random.uniform(-1, 1),
random.uniform(-1, 1))
self.vel.Unitize()
self.speed = 4
self.vel *= self.speed
self.acc = rg.Vector3d(0, 0, 0)
self.size = 5
self.cone = None
self.coneID = None
self.rotAngle = 0
#Color and Material
self.attr = rc.DocObjects.ObjectAttributes()
self.attr.ColorSource = rc.DocObjects.ObjectColorSource.ColorFromObject
grad = color.GetGradient(1)
self.attr.ObjectColor = color.GradientOfColors(grad,
random.uniform(0, 1))
self.attr.MaterialSource = rc.DocObjects.ObjectMaterialSource.MaterialFromObject
index = sc.doc.Materials.Add()
self.mat = sc.doc.Materials[index]
self.mat.DiffuseColor = self.attr.ObjectColor
self.mat.CommitChanges()
self.attr.MaterialIndex = index
#Position
self.pos = rg.Point3d(random.uniform(5, 95), random.uniform(5, 95),
random.uniform(5, 95))
self.plane = rg.Plane(self.pos, self.vel)
#self.sphere = rg.Sphere(self.pos, self.size )
#Bake
self.tempIDs = []
self.ids = []
#self.ids.append(sc.doc.Objects.AddSphere(self.sphere, self.attr))
self.coneIDs = []
def UpdateDisplay(self):
if self.id: sc.doc.Objects.Delete(self.id, True)
if len(self.belowVertices) > 0 and len(self.belowVertices) < 8:
self.attr.ObjectColor = color.GradientOfColors(
self.system.grad,
util.Remap(len(self.belowVertices), 0, 8, 0, 1), 2)
index = sc.doc.Materials.Add()
mat = sc.doc.Materials[index]
mat.DiffuseColor = self.attr.ObjectColor
mat.CommitChanges()
self.attr.MaterialIndex = index
xform = rg.Transform.Scale(
self.centerPt, util.Remap(len(self.belowVertices), 1, 7, .1,
1))
box = self.box.Duplicate()
box.Transform(xform)
self.id = sc.doc.Objects.AddMesh(box, self.attr)
def UpdateDisplay(self):
for id in self.ids:
sc.doc.Objects.Delete(id, True)
for i, pt in enumerate(self.path):
sphere = rg.Sphere(pt, .8)
self.attr.ObjectColor = color.GradientOfColors(
self.grad, util.Remap(i, 0, len(self.path), 0, 1), 3)
index = sc.doc.Materials.Add()
mat = sc.doc.Materials[index]
mat.DiffuseColor = self.attr.ObjectColor
mat.CommitChanges()
self.attr.MaterialIndex = index
self.ids.append(sc.doc.Objects.AddSphere(sphere, self.attr))
self.ids.append(sc.doc.Objects.AddMesh(self.mesh))
self.vObjects[self.sourceIndex].UpdateDisplay()
self.vObjects[self.targetIndex].UpdateDisplay()
def UpdateDisplay(self):
if self.id: sc.doc.Objects.Delete(self.id, True)
if len(self.interPts) >= 3:
r, plane = rg.Plane.FitPlaneToPoints(self.interPts)
if r == rg.PlaneFitResult.Success:
mesh = geo.DelaunayMesh(self.interPts, plane)
self.system.mesh.Append(mesh)
#self.id = sc.doc.Objects.AddMesh(mesh)
if False:
self.attr.ObjectColor = color.GradientOfColors(
self.system.grad,
util.Remap(len(self.belowVertices), 0, 8, 0, 1), 2)
index = sc.doc.Materials.Add()
mat = sc.doc.Materials[index]
mat.DiffuseColor = self.attr.ObjectColor
mat.CommitChanges()
self.attr.MaterialIndex = index
def Update(self, time):
grad = color.GetGradient(1)
self.attr.ObjectColor = color.GradientOfColors(
grad, util.Remap(time, 0, 150, 0, 1))
index = sc.doc.Materials.Add()
self.mat = sc.doc.Materials[index]
self.mat.DiffuseColor = self.attr.ObjectColor
self.mat.CommitChanges()
self.attr.MaterialIndex = index
self.openPlanes = self.nextRoundPlanes
self.openPlanes = self.openPlanes[:8]
self.nextRoundPlanes = []
planesToRemove = []
for plane in self.openPlanes:
planesToRemove.append(plane)
self.AddModule(plane)
for plane in planesToRemove:
self.openPlanes.remove(plane)
def InitTriangle(self):
xval = util.Remap(self.pos.X, 0, 100, 0, 1 * 2)
yval = util.Remap(self.pos.Y, 0, 100, 0, 1 * 2)
zval = util.Remap(self.pos.Z, 0, 100, 0, 1 * 5)
val = self.system.pn.noise3(xval + self.system.p.pos.X,
yval + self.system.p.pos.Y,
zval + self.system.p.pos.Z)
self.size = util.Remap(val, -1, 1, -2, 2)
if self.size > 0:
self.pt0 = rg.Point3f(0, self.size, 0)
self.pt1 = rg.Point3f(-self.size / 2, 0, 0)
self.pt2 = rg.Point3f(self.size / 2, 0, 0)
camPos = sc.doc.Views.ActiveView.ActiveViewport.CameraLocation
vec = camPos - self.pos
plane = rg.Plane(self.pos, vec)
testPt = self.pos + rg.Vector3f(0, 0, 1)
cp = plane.ClosestPoint(testPt)
yAxis = cp - self.pos
xprod = rg.Vector3d.CrossProduct(vec, yAxis)
plane = rg.Plane(self.pos, xprod, yAxis)
xform = rg.Transform.PlaneToPlane(rg.Plane.WorldXY, plane)
#self.xform = rg.Transform.PlaneToPlane(self.prevPlane, plane)
self.prevPlane = plane.Clone()
col = color.GradientOfColors(self.grad,
util.Remap(val, -1, 1, -1, 1), 2)
self.system.mesh.VertexColors.Add(col)
self.system.mesh.VertexColors.Add(col)
self.system.mesh.VertexColors.Add(col)
self.pt0.Transform(xform)
self.pt1.Transform(xform)
self.pt2.Transform(xform)
i0 = self.system.mesh.Vertices.Add(self.pt0)
i1 = self.system.mesh.Vertices.Add(self.pt1)
i2 = self.system.mesh.Vertices.Add(self.pt2)
self.system.mesh.Faces.AddFace(i0, i1, i2)
def __init__(self):
self.p = Target(rg.Point3d(50,50,50), rg.Vector3d(.05,0.05,0.05))
self.dots = []
self.time = 0
self.links = []
self.id = None
self.grad = color.GetGradient(10)
self.mesh = rg.Mesh()
self.pn = perlin.SimplexNoise()
for i in range(1000):
self.dots.append(Dot(self))
#Attr
self.attr = rc.DocObjects.ObjectAttributes()
self.attr.ColorSource = rc.DocObjects.ObjectColorSource.ColorFromObject
self.grad = color.GetGradient(10)
self.attr.ObjectColor = color.GradientOfColors(self.grad, 0)
self.attr.MaterialSource = rc.DocObjects.ObjectMaterialSource.MaterialFromObject
index = sc.doc.Materials.Add()
self.mat = sc.doc.Materials[index]
self.mat.DiffuseColor = self.attr.ObjectColor
self.mat.CommitChanges()
self.attr.MaterialIndex = index
def UpdateDisplay(self):
self.attr.ObjectColor = color.GradientOfColors(
self.grad, util.Remap(self.age, 0, 150, 0, 1))
self.attr.MaterialSource = rc.DocObjects.ObjectMaterialSource.MaterialFromObject
index = sc.doc.Materials.Add()
self.mat = sc.doc.Materials[index]
self.mat.DiffuseColor = self.attr.ObjectColor
self.mat.CommitChanges()
self.attr.MaterialIndex = index
if self.id: sc.doc.Objects.Delete(self.id, True)
self.id = sc.doc.Objects.AddBrep(self.boxBrep, self.attr)
for id in self.ids:
sc.doc.Objects.Delete(id, True)
edgesCurrent = self.boxBrep.GetWireframe(-1)
if len(self.edgesPrev):
for i in range(12):
crvA = edgesCurrent[i]
crvB = self.edgesPrev[i]
loft = rg.Brep.CreateFromLoft([crvA, crvB], rg.Point3d.Unset,
rg.Point3d.Unset,
rg.LoftType.Straight, False)
sc.doc.Objects.AddBrep(loft[0], self.attr)
def Update(self, time):
self.attr.ObjectColor = color.GradientOfColors(self.grad, util.Remap(time, 0, 150, 0, 1))
index = sc.doc.Materials.Add()
self.mat = sc.doc.Materials[index]
self.mat.DiffuseColor = self.attr.ObjectColor
self.mat.CommitChanges()
self.attr.MaterialIndex = index
prevTurn = self.turned
self.turned = False
self.prevVel = self.vel.Clone()
self.prevPlane = self.plane.Clone()
#Should I change?
futurePos = self.pos + self.vel
hitBoundary = False
f = 2
possibleCases = [0,1,2,3,4,5]
if futurePos.X < self.size * f:
hitBoundary = True
possibleCases.remove(1)
if futurePos.Y < self.size * f:
hitBoundary = True
possibleCases.remove(3)
if futurePos.Z < self.size * f:
hitBoundary = True
possibleCases.remove(5)
if futurePos.X > 100-self.size * f:
hitBoundary = True
possibleCases.remove(0)
if futurePos.Y > 100-self.size * f:
hitBoundary = True
possibleCases.remove(2)
if futurePos.Z > 100-self.size * f:
hitBoundary = True
possibleCases.remove(4)
#self.AvoidNeighborPaths()
#self.AvoidSelf()
if hitBoundary == True:
self.turned = True
self.case = random.choice(possibleCases)
if hitBoundary == False:
if time%random.randint(6, 10) == 0 and prevTurn == False:
self.turned = True
self.ChangeDirection()
self.vel = self.cases[self.case]*self.length
self.CreateRectangles()
if self.turned:
pass
#prevVel
#jog = self.vel
self.vel += self.prevVel
self.pos += self.vel
if len(self.history) > 20 and 1 == 2:
self.history = self.history[-20:]
if len(self.historyPos) > 30:
self.historyPos.pop(0)
def __init__(self, system, vec=None):
self.system = system
self.val = None
self.history = []
self.historyPos = []
self.pipeIDs = []
self.pipe = None
self.pipes = []
self.alive = True
self.size = random.uniform(1, 6)
self.length = self.size * 2
self.turned = False
self.prevVel = None
self.majorBrep = rg.Brep()
self.prevBrep = None
self.planes = []
self.ids = []
self.breps = []
self.straightSec = Module(self.size)
self.straightSec.CreateStraight()
self.angleSec = Module(self.size)
self.angleSec.CreateAngle()
self.uTurnSec = Module(self.size)
self.uTurnSec.CreateUturn()
self.TSec = Module(self.size)
self.TSec.CreateT()
self.cases = {
0: rg.Vector3d(1, 0, 0),
1: rg.Vector3d(-1, 0, 0),
2: rg.Vector3d(0, 1, 0),
3: rg.Vector3d(0, -1, 0),
4: rg.Vector3d(0, 0, 1),
5: rg.Vector3d(0, 0, -1)
}
self.case = random.randint(0, len(self.cases) - 1)
#Movement
#self.vel = rg.Vector3d(random.uniform(-1,1),random.uniform(-1,1), random.uniform(-.2,.2))
if vec is None:
self.vel = random.choice(self.cases)
else:
self.vel = vec
self.vel.Unitize()
self.tempVel = self.vel.Clone()
self.speed = self.length
self.vel *= self.speed
self.acc = rg.Vector3d(0, 0, 0)
self.size = 2
self.cone = None
self.coneID = None
self.rotAngle = 0
#Color and Material
self.attr = rc.DocObjects.ObjectAttributes()
self.attr.ColorSource = rc.DocObjects.ObjectColorSource.ColorFromObject
#self.grad = color.GetGradient(random.randint(0,9))
self.grad = color.GetGradient(4)
#col = drawing.Color.AliceBlue
self.attr.MaterialSource = rc.DocObjects.ObjectMaterialSource.MaterialFromObject
self.attr.ObjectColor = color.GradientOfColors(self.grad,
random.uniform(0, 1))
index = sc.doc.Materials.Add()
self.mat = sc.doc.Materials[index]
self.mat.DiffuseColor = self.attr.ObjectColor
self.mat.CommitChanges()
self.attr.MaterialIndex = index
self.attrCol1 = rc.DocObjects.ObjectAttributes()
self.attrCol1.ColorSource = rc.DocObjects.ObjectColorSource.ColorFromObject
self.attrCol1.ObjectColor = drawing.Color.Red
self.attrCol2 = rc.DocObjects.ObjectAttributes()
self.attrCol2.ColorSource = rc.DocObjects.ObjectColorSource.ColorFromObject
self.attrCol2.ObjectColor = drawing.Color.Green
self.attrCol3 = rc.DocObjects.ObjectAttributes()
self.attrCol3.ColorSource = rc.DocObjects.ObjectColorSource.ColorFromObject
self.attrCol3.ObjectColor = drawing.Color.Blue
#Position
self.pos = rg.Point3d(random.uniform(5, 95), random.uniform(5, 95),
random.uniform(5, 95))
#self.pos = rg.Point3d(50, 50, 50)
self.plane = rg.Plane(self.pos, self.vel)
self.planes.append(self.plane)
self.origin = rg.Point3d(self.pos)
#Bake
self.tempIDs = []
self.ids = []
self.coneIDs = []
self.id = None
