glitch3d 0.5.0.0 → 0.5.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a6891f01ce5cfa2a1f32042d4c8e8fd04d976b38
-  data.tar.gz: b33d3ef8d3a296835f1ee5807544f75537d06181
+  metadata.gz: e35a975d66a59b0803f10f9b4adff8a34cec401b
+  data.tar.gz: d408635bb3bcd718723929f54d2c743ef03275f1
 SHA512:
-  metadata.gz: 458c39cad088dcba2af7d28d82194aecf6fdfc3f89a05ce37b32a4e0250565bffb81611778925e0c81ce87098e84850cc0d2f0bae87bacb0f317b741172b59c9
-  data.tar.gz: 657088d23f8bb9dca698025a492f30cedf77cb58eb174296298e2439399c3ef26be43cf052e0b90b0306e3594ae9ee9e497809013582f64dec1ef0db14054715
+  metadata.gz: 75cf5cfa3091803d1f8706f5670fc947a7ec645297e24477685e8fab019683061df340dd2dc42ba423a019b27d928b4f2272b23ed47c46c01e5364c70d4b5475
+  data.tar.gz: d99b789dbf4829ff3993b24979360942a22b1a4070615af8e46d9d8644d6d0c4d23baa7d54392f56b9823b6fbaf988ea8ecb60f00283101b850e056e570e4a6d

data/.gitignore

@@ -20,4 +20,4 @@
 *.png
 lib/glitch3d/bpy/canvas/__pycache__/
 lib/glitch3d/bpy/__pycache__/
-fixtures/osl-shaders/*.oso
+fixtures/osl_shaders/*.oso

data/README.md

@@ -10,6 +10,13 @@ This gem uses the Blender Python API to produces renders headlessly and leverage
 
 Cycles rendering engine does not support GLSL shaders so the shader library is using a node-based system but could be extended to serialize materials in the Open Shading Language.
 
+## Overview of the process
+
+1) the subject model (main argument of the cli call) is altered by one of the available 'glitching' strategies
+2) the base Blender scene is loaded and the subject is loaded and ajusted
+3) random canvas objects are picked up and drawn across the scene
+4) actual render begins and the scene is animated in each frame
+
 ## :warning: Warning
 
 Setting `BLENDER_EXECUTABLE_PATH` in your environment is required. In general this gem relies on the presence of Python and Blender on the host machine. I am very aware this is not standard practice and plan to split components later down the road but this proves convenient for now.
@@ -35,11 +42,15 @@ Or install it yourself as:
 - `glitch3d file.obj`
 
 CLI Options:
-- `mode` : (localized|default|none) => glitching strategy
-- `shots-number` : integer representing the number of - images desired (with animate: false)
-- `quality` : (high: 2000 x 2000|low 200 x 200) default: low => size of the render
-- `animate` : (true) default: false => Render .avi file
-- `frames` : (default: 200) => number of frames for simulation
+- `mode`: (localized|default|none) default: randomized => glitching strategy (how the subject model is altered)
+- `shots-number`: default: 4 => the number of images desired (only taken into account if `animate` is false)
+- `quality`: (high|low) default: low => size of the render (low is 200x200 pixels and high is 2000x2000 pixels)
+- `animate`: (true|false) default: false => enables render of .avi file
+- `frames`: default: 200 => number of frames for the simulation
+- `assets`: default: nil => URI to an asset folder that has the following subfolders: `/osl_shaders` `/fonts` `/texts` `/textures` `/height_maps` `/models`
+- `debug`: (true|false) default: false => allows to re-raise errors from canvas specific code (otherwise the program just exits with status code 1)
+- `webhook`: default: nil => url of endpoint to post potential error data to (useful for debugging)
+- `seed`: default: rand(1000) => randomness seed that you can pass to the generator to reproduce a specific render result (useful for debugging and refining a canvas result)
 
 Renders (wether it is video or an image) will be output to `./renders` along with an export of the `.scene` file so that you can potentially fiddle with the resulting scene setup and adjust lights for instance.
 
@@ -61,10 +72,11 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Roadmap
 
-- extract fixtures management from gem
-- allow fixtures to be scraped from online resources such as [Thingiverse](https://www.thingiverse.com/)
-- use Blender Compositor feature to streamline post-processing
-- use realtime Eevee engine to visualize intermediate renders
+- [x] extract fixtures management from gem
+- [x] allow fixtures to be scraped from online resources such as [Thingiverse](https://www.thingiverse.com/)
+- [ ] use Blender Compositor feature to streamline post-processing
+- [ ] use realtime Eevee engine to visualize intermediate renders
+- [ ] support more 3D file formats (fbx, etc)
 
 ## Contributing
 

data/bin/glitch3d

@@ -10,7 +10,7 @@ args = Hash[ARGV.join(' ').scan(/--?([^=\s]+)(?:=(\S+))?/)] if args.nil?
 args.default = false
 
 if ARGV[0] && !ARGV[0].start_with?('--')
- source_file = ARGV[0]
+  source_file = ARGV[0]
 else
   source_file = nil
 end

data/lib/glitch3d.rb

@@ -6,17 +6,37 @@ require 'glitch3d/objects/face'
 Dir[File.dirname(__FILE__) + '/glitch3d/strategies/*.rb'].each { |file| require file }
 
 module Glitch3d
-  VERTEX_GLITCH_ITERATION_RATIO = 0.1
-  VERTEX_GLITCH_OFFSET = 1
+  class ProcessError < StandardError; end
 
-  FACE_GLITCH_ITERATION_RATIO = 0.1
-  FACE_GLITCH_OFFSET = 0.5
-  BOUNDARY_LIMIT = 3 # Contain model within BOUNDARY_LIMITxBOUNDARY_LIMITxBOUNDARY_LIMIT cube
-  CHUNK_SIZE=20
+  VERTEX_GLITCH_ITERATION_RATIO = 0.0001.freeze
+  VERTEX_GLITCH_OFFSET = 1.freeze
+
+  FACE_GLITCH_ITERATION_RATIO = 0.0001.freeze
+  FACE_GLITCH_OFFSET = 0.5.freeze
+  BOUNDARY_LIMIT = 3.freeze # Contain model within BOUNDARY_LIMITxBOUNDARY_LIMITxBOUNDARY_LIMIT cube
+  CHUNK_SIZE = 20.freeze
+  DEFAULT_SHOTS_NUMBER = 4.freeze
+  STRATEGIES = [
+    Glitch3d::Default,
+    Glitch3d::Duplication,
+    Glitch3d::FindAndReplace,
+    Glitch3d::Localized,
+    Glitch3d::None
+  ].freeze
 
   BLENDER_EXECUTABLE_PATH = ENV['BLENDER_EXECUTABLE_PATH'].freeze
   RENDERING_SCRIPT_PATH = File.dirname(__FILE__) + '/glitch3d/bpy/main.py'
   BASE_BLEND_FILE_PATH = File.dirname(__FILE__) + '/../fixtures/base.blend'
+  BENCHMARK_ARGS = {
+    'quality' => 'high',
+    'normals' => false,
+    'width' => 1000.to_s,
+    'height' => 1000.to_s,
+    'debug' => 'false',
+    'canvas' => 'empty',
+    'animate' => 'false',
+    'post-process' => 'false'
+  }
 
   ASCII_TITLE = "
   ██████╗ ██╗     ██╗████████╗ ██████╗██╗  ██╗██████╗ ██████╗
@@ -34,25 +54,53 @@ module Glitch3d
     create_glitched_file(glitch(read_source(source_file)), target_file, model_name)
   end
 
+  def benchmark_strategies(source_file, base_file_name, model_name)
+    require 'benchmark'
+    Benchmark.bm do |x|
+      STRATEGIES.each do |s|
+        new_model_name = model_name + "_#{s.to_s.downcase.gsub(/::/, '_')}"
+        target_file = new_model_name + '_glitched.obj'
+        x.report s do
+          create_glitched_file(
+            glitch(read_source(source_file), s),
+            target_file,
+            new_model_name
+          )
+        end
+      end
+    end
+    STRATEGIES.each do |s|
+      new_model_name = model_name + "_#{s.to_s.downcase.gsub(/::/, '_')}"
+      target_file = new_model_name + '_glitched.obj'
+      render(BENCHMARK_ARGS, target_file, 1)
+    end
+  end
+
   # @param String source_file, 3d model file to take as input
   # @param Hash args, parameters { 'stuff' => 'shit' }
   def process_model(source_file, args)
     raise 'Make sure Blender is correctly installed' if BLENDER_EXECUTABLE_PATH.nil?
+    @seed = args['seed'] ? args['seed'].to_i : rand(1000)
+    srand @seed
+    puts "Random seed: #{@seed}"
     puts ASCII_TITLE
     puts Glitch3d::VERSION
     return clean_model(source_file) if args['clean']
     source_file = random_fixture if source_file.nil?
     print_version if args.has_key?('version')
     raise 'Set Blender executable path in your env variables before using glitch3d' if BLENDER_EXECUTABLE_PATH.nil?
-    self.class.include infer_strategy(args['mode'])
-    @quality = args['quality'] || 'low'
     source_file = source_file
     base_file_name = source_file&.gsub(/.obj/, '')
     model_name = File.basename(source_file, '.obj')
     target_file = base_file_name + '_glitched.obj'
     puts "Target ~> #{target_file}"
-    create_glitched_file(glitch(read_source(source_file)), target_file, model_name)
-    render(args, target_file, args['shots-number'] || 6) unless args['no-render']
+    return benchmark_strategies(source_file, base_file_name, model_name) if args['benchmark']
+    create_glitched_file(
+      glitch(read_source(source_file), infer_strategy(args['mode'])),
+      target_file,
+      model_name
+    )
+    render(args, target_file, args['shots-number'] || DEFAULT_SHOTS_NUMBER) unless args['no-render']
   end
 
   # Print version number
@@ -78,7 +126,7 @@ module Glitch3d
   # @return [Glitch3d::Strategy]
   def infer_strategy(mode)
     if !mode
-      mode_chosen = [ Glitch3d::Default, Glitch3d::Duplication, Glitch3d::FindAndReplace, Glitch3d::Localized, Glitch3d::None].sample
+      mode_chosen = STRATEGIES.sample
       puts "Strategy defaulting to #{mode_chosen}"
       return mode_chosen
     end
@@ -133,20 +181,15 @@ module Glitch3d
     faces_list
   end
 
-  def glitch(file_hash_content)
+  def glitch(file_hash_content, strategy)
     {
-      vertices: alter_vertices(file_hash_content[:vertices]),
-      faces: alter_faces(file_hash_content[:faces], file_hash_content[:vertices])
+      vertices: strategy.public_send(:alter_vertices, file_hash_content[:vertices]),
+      faces: strategy.public_send(:alter_faces, file_hash_content[:faces], file_hash_content[:vertices])
     }
   end
 
-  def random_element(array)
-    array[rand(0..array.size - 1)]
-  end
-
   def create_glitched_file(content_hash, target_file, model_name)
     boundaries = Vertex.boundaries(content_hash[:vertices])
-    puts boundaries.to_s
     while rescale_needed?(boundaries)
       content_hash[:vertices] = Vertex.rescale(content_hash[:vertices], (boundaries.flatten.map(&:abs).max.abs - BOUNDARY_LIMIT).abs)
       boundaries = Vertex.boundaries(content_hash[:vertices])
@@ -182,7 +225,7 @@ module Glitch3d
       '-n',
       shots_number.to_s,
       '-m',
-      @quality,
+      initial_args['quality'] || 'low',
       '-p',
       File.dirname(__FILE__).to_s,
       '-a',
@@ -198,8 +241,18 @@ module Glitch3d
       '-eight',
       initial_args['height'] || 2000.to_s,
       '-canvas',
-      initial_args['canvas'] || nil.to_s
+      initial_args['canvas'] || nil.to_s,
+      '-assets',
+      initial_args['assets'] || nil.to_s,
+      '--post-process',
+      initial_args['post-process'].to_s.capitalize,
+      '--webhook',
+      initial_args['webhook'] || nil.to_s,
+      '--seed',
+      @seed.to_s,
+      '--python-exit-code',
+      1.to_s
     ]
-    system(*args)
+    raise(ProcessError, "bpy run failed, enable --debug=true for Python debugging") unless system(*args)
   end
 end

data/lib/glitch3d/bpy/canvas/aether.py

@@ -5,66 +5,30 @@ import helpers
 
 class Aether(canvas.Canvas):
   def render(self):
-    ######################
-    ## FLUID SIMULATION ##
-    ######################
-    RADIUS=20
-
-    bpy.ops.mesh.primitive_cube_add(location=(0.0, 0.0, 17),radius=RADIUS)
-    container = bpy.context.object
-    container.name = 'fluid_container'
-    container.modifiers.new(name='container', type='FLUID_SIMULATION')
-    container.modifiers.new(name='smooth_container', type='SMOOTH')
-    container.modifiers['container'].settings.type = 'DOMAIN'
-    container.modifiers['container'].settings.generate_particles = 5
-    container.modifiers['container'].settings.surface_subdivisions = 50
-    container.modifiers['container'].settings.viscosity_exponent = 6
-    container.modifiers['container'].settings.viscosity_base = 1.0
-    container.modifiers['container'].settings.resolution = 25
-    container.modifiers['container'].settings.simulation_scale = 1
-    container.modifiers['container'].settings.simulation_rate = 5
-
-    self.spawn_emitter_fluid((-2,-2,10),mathutils.Vector((-0.5, -0.5, -2)))
-    self.spawn_emitter_fluid((2,2,10),mathutils.Vector((0.5, 0.5, -2)))
-
-    helpers.assign_material(container, helpers.random_material(self.MATERIALS_NAMES))
-
+    RADIUS=3
     ######################
     ## SMOKE SIMULATION ##
     ######################
-
-    # bpy.ops.mesh.primitive_cube_add(location=(0.0, 0.0, 17),radius=RADIUS)
-    # container = bpy.context.object
-    # container.name = 'smoke_container'
-    # container.modifiers.new(name='container', type='SMOKE')
-    # container.modifiers['container'].smoke_type = 'DOMAIN'
-    # container.modifiers['container'].domain_settings.use_high_resolution = True
-    # container.modifiers['container'].domain_settings.vorticity = 3
-    # self.spawn_emitter_smoke(self.ORIGIN)
-    # self.make_object_smoke_collider(self.SUBJECT)
-
-    # Bake animation
-    print("*** Baking commence *** (you might see a bunch of gibberish popping up cause baking is not supposed to be used headlessly")
-    bpy.ops.ptcache.free_bake_all() # free bake cache
-    bpy.ops.ptcache.bake_all(bake = True)
-    print("*** Baking finished ***")
-
-  def spawn_emitter_fluid(self, location, emission_vector):
-    bpy.ops.mesh.primitive_uv_sphere_add(location=location)
-    emitter = bpy.context.object
-    emitter.cycles_visibility.camera = False
-    emitter.name = 'fluid_emitter_' + str(uuid.uuid1())
-    emitter.modifiers.new(name='emitter', type='FLUID_SIMULATION')
-    emitter.modifiers['emitter'].settings.type = 'INFLOW'
-    emitter.modifiers['emitter'].settings.inflow_velocity = emission_vector
-    emitter.scale = (0.5, 0.5, 0.5)
-    return emitter
-
-  def make_object_fluid_collider(self, obj):
-      obj.modifiers.new(name='obstacle', type='FLUID_SIMULATION')
-      obj.modifiers['obstacle'].settings.type = 'OBSTACLE'
-      obj.modifiers['obstacle'].settings.volume_initialization = 'BOTH'
-      obj.modifiers['obstacle'].settings.partial_slip_factor = 0.15
+    bpy.ops.mesh.primitive_cube_add(location=(0.0, 0.0, 4.0),radius=RADIUS)
+    container = bpy.context.object
+    container.name = 'smoke_container'
+    container.modifiers.new(name='container', type='SMOKE')
+    container.modifiers['container'].smoke_type = 'DOMAIN'
+    container.modifiers['container'].domain_settings.use_high_resolution = True
+    container.modifiers['container'].domain_settings.vorticity = 3
+    container.modifiers['container'].domain_settings.vorticity = 3
+    container.modifiers["container"].domain_settings.alpha = - 1.2
+    helpers.assign_material(container, bpy.data.materials['Smoke Domain Material'])
+    emitter = self.spawn_emitter_smoke(self.ORIGIN)
+    self.make_object_smoke_collider(self.SUBJECT)
+
+    emitter.modifiers["emitter"].flow_settings.density = 1
+    bpy.context.scene.frame_set(0)
+    emitter.location = helpers.rand_location(7, positive=True)
+    helpers.add_frame([emitter], ['location'])
+    bpy.context.scene.frame_set(self.NUMBER_OF_FRAMES)
+    emitter.location = (4,4,4)
+    helpers.add_frame([emitter], ['location'])
 
   def spawn_emitter_smoke(self, location, obj = None):
     bpy.ops.mesh.primitive_uv_sphere_add(location=location)
@@ -75,7 +39,7 @@ class Aether(canvas.Canvas):
     emitter.modifiers['emitter'].smoke_type = 'FLOW'
     emitter.modifiers['emitter'].flow_settings.smoke_color = (helpers.rand_color_value(), helpers.rand_color_value(), helpers.rand_color_value())
     emitter.modifiers['emitter'].flow_settings.temperature = 1
-    emitter.scale = (3,3,3)
+    emitter.scale = (0.4,0.4,0.4)
     return emitter
 
   def make_object_smoke_collider(self, obj):

data/lib/glitch3d/bpy/canvas/dreamatorium.py

@@ -8,7 +8,7 @@ class Dreamatorium(canvas.Canvas):
         props = []
         bpy.ops.import_scene.obj(filepath = os.path.join(self.MODELS_FOLDER_PATH + 'lightning.obj'), use_edges=True)
         logo = bpy.context.selected_objects[0]
-        logo.location = self.rand_location(self.CANVAS_BOUNDARY)
+        logo.location = helpers.rand_location(self.CANVAS_BOUNDARY)
         props.append(logo)
 
         bpy.ops.mesh.primitive_grid_add(x_subdivisions=100, y_subdivisions=100, location=(0, 6, 2))
@@ -42,13 +42,12 @@ class Dreamatorium(canvas.Canvas):
                 props.append(new_line)
 
         ocean = self.add_ocean(10, 20)
-        helpers.apply_displacement(ocean, self.HEIGHT_MAP_FOLDER_PATH)
 
         for index in range(1, 5):
             new_object = helpers.spawn_text(self.TEXT_FILE_PATH)
             bpy.data.groups['texts'].objects.link(new_object)
             props.append(new_object)
-            self.assign_material(new_object, helpers.random_material(self.MATERIALS_NAMES))
+            helpers.assign_material(new_object, helpers.random_material(self.MATERIALS_NAMES))
             text_scale = random.uniform(0.75, 3)
             new_object.scale = (text_scale, text_scale, text_scale)
             new_object.location = helpers.rand_location(self.CANVAS_BOUNDARY)
@@ -63,7 +62,6 @@ class Dreamatorium(canvas.Canvas):
             helpers.shuffle(prop, self.CANVAS_BOUNDARY)
             helpers.assign_material(prop, helpers.random_material(self.MATERIALS_NAMES))
 
-
     def add_ocean(self, spatial_size, resolution, depth = 100, scale=(4,4,4), wave_scale = 0.5):
         bpy.ops.mesh.primitive_cube_add(location=(0, 0, -0.4),radius=1)
         ocean = bpy.context.object
@@ -73,10 +71,6 @@ class Dreamatorium(canvas.Canvas):
         ocean.modifiers["Ocean"].resolution = resolution
         ocean.modifiers["Ocean"].wave_scale = wave_scale
         ocean.modifiers["Ocean"].depth = depth
-        helpers.assign_material(ocean, helpers.fetch_material("jello"))
-        shadow = helpers.duplicate_object(ocean)
-        shadow.location += mathutils.Vector((1,1,-0.4))
-        helpers.wireframize(shadow, random.choice(self.COLORS))
-        shadow.name = 'shadow'
+        helpers.wireframize(ocean, random.choice(self.COLORS))
         ocean.name = 'ocean'
         return ocean

data/lib/glitch3d/bpy/canvas/empty.py

@@ -0,0 +1,8 @@
+import sys, code, random, os, math, bpy, mathutils, uuid, canvas
+
+sys.path.append(os.path.dirname(os.path.dirname(__file__)))
+import helpers
+
+class Empty(canvas.Canvas):
+  def render(self):
+    return True

data/lib/glitch3d/bpy/canvas/fernandez.py

@@ -1,13 +1,12 @@
 # Matthew Plummer Fernandez hommage
 # Draw interesting parametric curves and instantiate meshes on its path
-import sys, code, random, os, math, bpy, canvas
+import sys, code, random, os, math, bpy, canvas, mathutils
 
 sys.path.append(os.path.dirname(os.path.dirname(__file__)))
 import helpers
 
 class Fernandez(canvas.Canvas):
-  MESH_NUMBER_LIMIT = 200 # otherwise Blender crashes
-  MESH_OCCURENCE = 2 # 1 mesh every X point of the curve
+  MESH_OCCURENCE = 1 # 1 mesh every X point of the curve
 
   FUNCTIONS = [
     # decorated knot (can expand to 20 units)
@@ -37,15 +36,25 @@ class Fernandez(canvas.Canvas):
   ]
 
   def render(self):
-    art = self.matthew_curve(self.SUBJECT, 50)
-    helpers.assign_material(art, helpers.random_material(self.MATERIALS_NAMES))
+    base_particle = helpers.infer_primitive(random.choice(self.PRIMITIVES), location = (100, 100, 100), radius=1)
+    art = self.matthew_curve(self.SUBJECT, 20)
+    self.spawn_particles_system(art, base_particle)
+
+    for f in range(self.NUMBER_OF_FRAMES):
+      bpy.context.scene.frame_set(f)
+      art.particle_systems["ParticleSystem"].seed += 1
+      settings = bpy.data.particles[-1]
+      settings.particle_size += 0.005
+      art.scale += mathutils.Vector((0.02,0.02,0.02))
+      helpers.add_frame([art], ['particle_systems["ParticleSystem"].seed', 'scale'])
+      helpers.add_frame([settings], ['particle_size'])
 
   def rand_curve(self):
     return random.choice(self.FUNCTIONS)
 
   def matthew_curve(self, obj, time, scale = 0.2):
     fx, fy, fz = self.rand_curve()
-    verts =  [(fx(t), fy(t), fz(t)) for t in helpers.pitched_array(0, time, 1)]
+    verts =  [(fx(t), fy(t), fz(t)) for t in helpers.pitched_array(0, time, 0.2)]
     bpy.context.scene.objects.active = obj
     bpy.ops.object.select_all(action='DESELECT')
     for idx, coord in enumerate(verts[0::self.MESH_OCCURENCE]):
@@ -60,8 +69,25 @@ class Fernandez(canvas.Canvas):
     res.name = 'fernandez'
     helpers.resize(res)
     helpers.center(res)
-    res = helpers.create_mesh('fernandez_support', verts, [], (0,0,0),  [[v, v+1] for v in range(0, (len(verts) - 1))])
-    helpers.resize(res)
-    helpers.center(obj)
-    helpers.extrude(res)
+    helpers.decimate(res)
+    helpers.assign_material(res, helpers.random_material(self.MATERIALS_NAMES))
+    support = helpers.create_mesh('fernandez_support', verts, [], (0,0,0),  [[v, v+1] for v in range(0, (len(verts) - 1))])
+    helpers.resize(support)
+    helpers.center(support)
+    helpers.extrude(support)
+    helpers.assign_material(support, helpers.random_material(self.MATERIALS_NAMES))
     return res
+
+  def spawn_particles_system(self, base, obj):
+    base.modifiers.new("Particles", type='PARTICLE_SYSTEM')
+    settings = bpy.data.particles[-1]
+    settings.emit_from = 'VERT'
+    settings.physics_type = 'NO'
+    settings.count = 2000 # default 1000
+    settings.particle_size = 0.01
+    settings.render_type = 'OBJECT'
+    settings.dupli_object = obj
+    settings.show_unborn = True
+    settings.use_dead = True
+    settings.size_random = 0.5
+    bpy.ops.object.duplicates_make_real()