1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
|
# ##### BEGIN GPL LICENSE BLOCK #####
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software Foundation,
# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#
# ##### END GPL LICENSE BLOCK #####
import bpy
from bpy.props import *
import os
import math
import mathutils
__bpydoc__ = """
Light Field Tools
This script helps setting up rendering of lightfields. It
also supports the projection of lightfields with textured
spotlights.
Usage:
A simple interface can be accessed in the tool shelf panel
in 3D View ([T] Key).
A base mesh has to be provided, which will normaly be a
subdivided plane. The script will then create a camera rig
and a light rig with adjustable properties. A sample camera
and a spotlight will be created on each vertex of the
basemesh object axis (maybe vertex normal in future
versions).
Vertex order:
The user has to provide the number of cameras or
lights in one row in an unevenly spaced grid, the
basemesh. Then the right vertex order can be
computed as shown here.
6-7-8
| | |
^ 3-4-5
| | | |
y 0-1-2
x->
There is also a tool to create a basemesh, which is an
evenly spaced grid. The row length parameter is taken to
construct such a NxN grid. Someone would start out by adding
a rectengular plane as the slice plane of the frustrum of
the most middle camera of the light field rig. The spacing
parameter then places the other cameras in a way, so they
have an offset of n pixels from the other camera on this
plane.
Version history:
v0.2.1 - Empty handler, multiple camera grid, r34843
v0.2.0 - To be included in contrib, r34456
v0.1.4 - To work with r34261
v0.1.3 - Fixed base mesh creation for r29998
v0.1.2 - Minor fixes, working with r29994
v0.1.1 - Basemesh from focal plane.
v0.1.0 - API updates, draft done.
v0.0.4 - Texturing.
v0.0.3 - Creates an array of non textured spotlights.
v0.0.2 - Renders lightfields.
v0.0.1 - Initial version.
TODO:
* Restore view after primary camera is changed.
* Apply object matrix to normals.
* Allign to normals, somehow,....
* StringPropertie with PATH tag, for proper ui.
"""
class OBJECT_OT_create_lightfield_rig(bpy.types.Operator):
"""Create a lightfield rig based on the active object/mesh"""
bl_idname="object.create_lightfield_rig"
bl_label="Create a light field rig based on the active object/mesh"
bl_options = {'REGISTER'}
layer0 = [True] + [False]*19
numSamples = 0
baseObject = None
handler = None
verts = []
imagePaths = []
def arrangeVerts(self):
"""Sorts the vertices as described in the usage part of the doc."""
# get mesh with applied modifer stack
scene = bpy.context.scene
mesh = self.baseObject.to_mesh(scene, True, "PREVIEW")
verts = []
row_length = scene.lightfield.row_length
for vert in mesh.vertices:
# world/parent origin
co = vert.co * self.baseObject.matrix_local
normal = vert.normal
verts.append([co, normal])
def key_x(v):
return v[0][0]
def key_y(v):
return v[0][1]
verts.sort(key=key_y)
sorted_verts = []
for i in range(0, len(verts), row_length):
row = verts[i:i+row_length]
row.sort(key=key_x)
sorted_verts.extend(row)
return sorted_verts
def createCameraAnimated(self):
scene = bpy.context.scene
bpy.ops.object.camera_add(view_align=False)
cam = bpy.context.active_object
cam.name = "light_field_camera"
# set props
cam.data.angle = scene.lightfield.angle
# display options of the camera
cam.data.lens_unit = 'DEGREES'
# handler parent
if scene.lightfield.create_handler:
cam.parent = self.handler
# set as primary camera
scene.camera = cam
### animate ###
scene.frame_current = 0
for frame, vert in enumerate(self.verts):
scene.frame_current = frame
# translate
cam.location = vert[0]
# rotation
cam.rotation_euler = self.baseObject.rotation_euler
# insert LocRot keyframes
cam.keyframe_insert('location')
# set anim render props
scene.frame_current = 0
scene.frame_start = 0
scene.frame_end = self.numSamples-1
def createCameraMultiple(self):
scene = bpy.context.scene
for cam_idx, vert in enumerate(self.verts):
# add and name camera
bpy.ops.object.camera_add(view_align=False)
cam = bpy.context.active_object
cam.name = "light_field_cam_" + str(cam_idx)
# translate
cam.location = vert[0]
# rotation
cam.rotation_euler = self.baseObject.rotation_euler
# set camera props
cam.data.angle = scene.lightfield.angle
# display options of the camera
cam.data.draw_size = 0.15
cam.data.lens_unit = 'DEGREES'
# handler parent
if scene.lightfield.create_handler:
cam.parent = self.handler
def createCamera(self):
if bpy.context.scene.lightfield.animate_camera:
self.createCameraAnimated()
else:
self.createCameraMultiple()
def getImagePaths(self):
path = bpy.context.scene.lightfield.texture_path
if not os.path.isdir(path):
return False
files = os.listdir(path)
if not len(files) == self.numSamples:
return False
files.sort()
self.imagePaths = list(map(lambda f : os.path.join(path, f), files))
return True
def createTexture(self, index):
name = "light_field_spot_tex_" + str(index)
tex = bpy.data.textures.new(name)
# change type
tex.type = 'IMAGE'
tex = tex.recast_type()
# load and set the image
img = bpy.data.images.new("lfe_str_" + str(index))
img.filepath = self.imagePaths[index]
img.source = 'FILE'
tex.image = img
return tex
def createSpot(self, index, textured=False):
scene = bpy.context.scene
bpy.ops.object.lamp_add(
type='SPOT',
layers=self.layer0)
spot = bpy.context.active_object
# set object props
spot.name = "light_field_spot_" + str(index)
# set constants
spot.data.use_square = True
spot.data.shadow_method = "RAY_SHADOW"
# FIXME
spot.data.distance = 10
# set spot props
spot.data.energy = scene.lightfield.light_intensity / self.numSamples
spot.data.spot_size = scene.lightfield.angle
spot.data.spot_blend = scene.lightfield.spot_blend
# add texture
if textured:
spot.data.active_texture = self.createTexture(index)
# texture mapping
spot.data.texture_slots[0].texture_coordinates = 'VIEW'
# handler parent
if scene.lightfield.create_handler:
spot.parent = self.handler
return spot
def createLightfieldEmitter(self, textured=False):
for i, vert in enumerate(self.verts):
spot = self.createSpot(i, textured)
spot.location = vert[0]
spot.rotation_euler = self.baseObject.rotation_euler
def execute(self, context):
scene = context.scene
obj = self.baseObject = context.active_object
if not obj or obj.type != 'MESH':
self.report({'ERROR'}, "No selected mesh object!")
return 'CANCELLED'
self.verts = self.arrangeVerts()
self.numSamples = len(self.verts)
if scene.lightfield.create_handler:
#create an empty
bpy.ops.object.add(type='EMPTY')
empty = bpy.context.active_object
empty.location = self.baseObject.location
empty.rotation_euler = self.baseObject.rotation_euler
self.handler = empty
if scene.lightfield.do_camera:
self.createCamera()
if scene.lightfield.do_projection:
if self.getImagePaths():
self.createLightfieldEmitter(textured=True)
else:
self.createLightfieldEmitter(textured=False)
return 'FINISHED'
class OBJECT_OT_create_lightfield_basemesh(bpy.types.Operator):
"""Creates a basemsh from the selected focal plane"""
bl_idname="object.create_lightfield_basemesh"
bl_label="Create a basemesh from the selected focal plane"
bl_options = {'REGISTER'}
objName = "lf_basemesh"
def getWidth(self, obj):
mat = obj.matrix_local
mesh = obj.data
v0 = mesh.vertices[mesh.edges[0].vertices[0]].co * mat
v1 = mesh.vertices[mesh.edges[0].vertices[1]].co * mat
return (v0-v1).length
def getCamVec(self, obj, angle):
width = self.getWidth(obj)
itmat = obj.matrix_local.inverted().transposed()
normal = (obj.data.faces[0].normal * itmat).normalized()
vl = (width/2) * (1/math.tan(math.radians(angle/2)))
return normal*vl
def addMeshObj(self, mesh):
scene = bpy.context.scene
for o in scene.objects:
o.select = False
mesh.update()
nobj = bpy.data.objects.new(self.objName, mesh)
scene.objects.link(nobj)
nobj.select = True
if scene.objects.active == None or scene.objects.active.mode == 'OBJECT':
scene.objects.active = nobj
def execute(self, context):
scene = context.scene
obj = context.active_object
# check if active object is a mesh object
if not obj or obj.type != 'MESH':
self.report({'ERROR'}, "No selected mesh object!")
return 'CANCELLED'
# check if it has one single face
if len(obj.data.faces) != 1:
self.report({'ERROR'}, "The selected mesh object has to have exactly one quad!")
return 'CANCELLED'
rl = scene.lightfield.row_length
# use a degree angle here
angle = math.degrees(scene.lightfield.angle)
spacing = scene.lightfield.spacing
# resolution of final renderings
res = round(scene.render.resolution_x * (scene.render.resolution_percentage/100.))
width = self.getWidth(obj)
# the offset between n pixels on the focal plane
fplane_offset = (width/res) * spacing
# vertices for the basemesh
verts = []
# the offset vector
vec = self.getCamVec(obj, angle)
# lower left coordinates of the grid
sx = obj.location[0] - fplane_offset * int(rl/2)
sy = obj.location[1] - fplane_offset * int(rl/2)
z = obj.location[2]
# position on the focal plane
fplane_pos = mathutils.Vector()
for x in [sx + fplane_offset*i for i in range(rl)]:
for y in [sy + fplane_offset*i for i in range(rl)]:
fplane_pos.x = x
fplane_pos.y = y
fplane_pos.z = z
# position of a vertex in a basemesh
pos = fplane_pos + vec
# pack coordinates flat into the vert list
verts.append( (pos.x, pos.y, pos.z) )
# setup the basemesh and add verts
mesh = bpy.data.meshes.new(self.objName)
mesh.from_pydata(verts, [], [])
self.addMeshObj(mesh)
return 'FINISHED'
class VIEW3D_OT_lightfield_tools(bpy.types.Panel):
bl_space_type = "VIEW_3D"
bl_region_type = "TOOLS"
bl_context = "objectmode"
bl_label = "Light Field Tools"
def draw(self, context):
scene = context.scene
layout = self.layout
row = layout.row()
col = layout.column()
col.prop(scene.lightfield, "row_length")
col.prop(scene.lightfield, "angle")
col.prop(scene.lightfield, "create_handler")
col.prop(scene.lightfield, "do_camera")
col.prop(scene.lightfield, "animate_camera")
col.prop(scene.lightfield, "do_projection")
if (scene.lightfield.do_projection):
sub = layout.row()
subcol = sub.column(align=True)
subcol.prop(scene.lightfield, "texture_path")
subcol.prop(scene.lightfield, "light_intensity")
subcol.prop(scene.lightfield, "light_spot_blend")
# create a basemesh
sub = layout.row()
subcol = sub.column(align=True)
subcol.operator("object.create_lightfield_basemesh", "Create Base Grid")
subcol.prop(scene.lightfield, "spacing")
layout.operator("object.create_lightfield_rig", "Create Rig")
|