glitch3d 0.1.0

data/glitch3d.gemspec

@@ -0,0 +1,34 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'glitch3d/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "glitch3d"
+  spec.version       = Glitch3d::VERSION
+  spec.authors       = ["pskl"]
+  spec.email         = ["hello@pascal.cc"]
+
+  spec.summary       = %q{Alter 3D models and renders pictures.}
+  spec.description   = %q{Glitch3D is a library designed to transform a 3D model randomly and render screenshots.}
+  spec.homepage      = "http://pascal.cc"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  # if spec.respond_to?(:metadata)
+  #   spec.metadata['allowed_push_host'] = "TODO: Set to 'http://mygemserver.com'"
+  # else
+  #   raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
+  # end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "bin"
+  spec.executables   = ["glitch3d"]
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.12"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "byebug"
+end

data/lib/glitch3d/bpy/helpers.py

@@ -0,0 +1,97 @@
+# Helper methods
+def look_at(camera_object, point):
+    location_camera = camera_object.matrix_world.to_translation()
+    location_point = point.matrix_world.to_translation()
+    direction = location_point - location_camera
+    rot_quat = direction.to_track_quat('-Z', 'Y')
+    camera_object.rotation_euler = rot_quat.to_euler()
+
+def empty_materials():
+    mats = bpy.data.materials
+    for mat in mats.keys():
+        mats.remove(mats[mat])
+
+def shoot(camera, model_object, filepath):
+    look_at(camera, model_object)
+    print('Camera now at location: ' + camera_location_string(camera) + ' / rotation: ' + camera_rotation_string(camera))
+    bpy.context.scene.render.filepath = filepath
+    bpy.ops.render.render(write_still=True)
+
+def output_name(index, model_path):
+    return 'renders/' + os.path.splitext(model_path)[0].split('/')[1] + '_' + str(index) + '_' + str(datetime.date.today()) + '.png'
+
+def rotate(model_object, index):
+    model_object.rotation_euler[2] = math.radians(index * (360.0 / shots_number))
+
+def rand_color_value():
+    return round(random.uniform(0.1, 1.0), 10)
+
+def rand_location():
+    return (rand_location_value(), rand_location_value(), rand_location_value())
+
+def rand_rotation():
+    return (rand_rotation_value(), rand_rotation_value(), rand_rotation_value())
+
+def rand_rotation_value():
+    return round(random.uniform(0, 1), 10)
+
+def rand_location_value():
+    return round(random.uniform(-8, 8), 10)
+
+def rand_color_vector():
+    return (rand_color_value(), rand_color_value(), rand_color_value(), 1)
+
+def rand_scale():
+    return round(random.uniform(0, 0.3), 10)
+
+def get_args():
+  parser = argparse.ArgumentParser()
+
+  # get all script args
+  _, all_arguments = parser.parse_known_args()
+  double_dash_index = all_arguments.index('--')
+  script_args = all_arguments[double_dash_index + 1: ]
+
+  # add parser rules
+  parser.add_argument('-f', '--file', help="obj file to render")
+  parser.add_argument('-n', '--shots-number', help="number of shots desired")
+  parser.add_argument('-m', '--mode', help="quality mode: low | high")
+
+  parsed_script_args, _ = parser.parse_known_args(script_args)
+  return parsed_script_args
+
+def camera_rotation_string(camera):
+    return str(int(camera.rotation_euler.x)) + ' ' + str(int(camera.rotation_euler.y)) + ' ' + str(int(camera.rotation_euler.z))
+
+def camera_location_string(camera):
+    return str(int(camera.location.x)) + ' ' + str(int(camera.location.y)) + ' ' + str(int(camera.location.z))
+
+def assign_material(model_object, material):
+    model_object.data.materials.append(material)
+
+def assign_node_to_output(material, new_node):
+    assert material.use_nodes == True
+    output_node = material.node_tree.nodes['Material Output']
+    material.node_tree.links.new(new_node.outputs[0], output_node.inputs['Surface'])
+
+def create_cycles_material():
+    material = bpy.data.materials.new('Object Material - ' + str(uuid.uuid1()))
+    material.use_nodes = True
+
+    nodes = material.node_tree.nodes
+    new_node = nodes.new(random.choice(SHADERS))
+
+    assign_node_to_output(material, new_node)
+    return material
+
+def assign_random_texture_to_material(material):
+    assert material.use_nodes == True
+    bsdf_node = material.node_tree.nodes['Diffuse BSDF']
+    assign_node_to_output(material, bsdf_node)
+    texture_node = material.node_tree.nodes.new('ShaderNodeTexture')
+    material.node_tree.links.new(texture_node.outputs[0], bsdf_node.inputs[0])
+    # code.interact(local=dict(globals(), **locals()))
+    texture_path = os.path.expanduser('fixtures/textures/25.jpg')
+    new_texture = bpy.data.textures.new('ColorTex', type = 'IMAGE')
+    new_texture.image = bpy.data.images.load(texture_path)
+    texture_node.texture = new_texture

data/lib/glitch3d/bpy/rendering.py

@@ -0,0 +1,159 @@
+# Rendering script
+# Run by calling the blender executable with -b -P <script_name>
+# Disclaimer: I never did Python before so this is mostly hacks
+#
+# process:
+# 1) Load model given as a parameter
+# 2) Create emitting surfaces to act as lamps
+# 3) Create camera
+# 4) Rotate model and shoot image at each step
+#
+# Use `code.interact(local=dict(globals(), **locals()))` to pry into the script
+
+import bpy
+import os
+import argparse
+import datetime
+import bmesh
+import random
+import code
+import math
+import mathutils
+import random
+import uuid
+
+exec(open("lib/glitch3d/bpy/helpers.py").read())
+
+# Arguments parsing
+args = get_args()
+file = args.file
+mode = args.mode
+shots_number = int(args.shots_number)
+
+context = bpy.context
+
+REFLECTOR_SCALE = 5
+REFLECTOR_STRENGTH = 12
+REFLECTOR_LOCATION_PADDING = 10
+PROPS_NUMBER = 100
+SHADERS = ['ShaderNodeBsdfGlossy', 'ShaderNodeBsdfDiffuse', 'ShaderNodeBsdfVelvet']
+
+# Scene
+new_scene = bpy.data.scenes.new("Automated Render Scene")
+bpy.ops.scene.delete() # Delete old scene
+context.screen.scene = new_scene # selects the new scene as the current one
+
+# Render settings
+context.scene.render.resolution_x = 1920
+context.scene.render.resolution_y = 1080
+context.scene.render.engine = 'CYCLES'
+context.scene.render.resolution_percentage = 25
+# bpy.context.scene.cycles.device = 'GPU'
+context.scene.render.image_settings.compression = 0
+context.scene.cycles.samples = 25
+context.scene.render.image_settings.color_mode ='RGBA'
+context.scene.render.image_settings.file_format='PNG'
+
+if mode == 'high':
+    context.scene.render.image_settings.compression = 90
+    context.scene.cycles.samples = 500
+    context.scene.render.resolution_percentage = 100
+
+# Load model
+model_path = os.path.join(file)
+bpy.ops.import_scene.obj(filepath = model_path, use_edges=True)
+model_object = bpy.data.objects['Glitch3D']
+
+# Use center of mass to center object
+model_object.select = True
+bpy.ops.object.origin_set(type="ORIGIN_CENTER_OF_MASS")
+model_object.location = (0, 0, 0)
+
+# --------------
+# Create camera
+# --------------
+camera_data = bpy.data.cameras.new('Render Camera')
+bpy.data.objects.new('Render Camera', object_data=camera_data)
+camera_object = bpy.data.objects['Render Camera']
+new_scene.objects.link(camera_object)
+camera_object.location = (8, 8, 0)
+
+# Add reflectors
+bpy.ops.mesh.primitive_plane_add(location=(0,8 + REFLECTOR_LOCATION_PADDING, 0))
+bpy.ops.mesh.primitive_plane_add(location=(8 + REFLECTOR_LOCATION_PADDING,0,0))
+
+plane1 = bpy.data.objects['Plane']
+plane2 = bpy.data.objects['Plane.001']
+
+# Adjust camera
+context.scene.camera = camera_object
+look_at(camera_object, model_object)
+assign_material(model_object, create_cycles_material())
+
+for index, plane in enumerate([plane1, plane2]):
+    plane.scale = (REFLECTOR_SCALE, REFLECTOR_SCALE, REFLECTOR_SCALE)
+    plane.rotation_euler.x += math.radians(90)
+    emissive_material = bpy.data.materials.new('Emissive Material #' + str(index))
+    emissive_material.use_nodes = True
+    emission_node = emissive_material.node_tree.nodes.new('ShaderNodeEmission')
+    # Set color
+    emission_node.inputs[0].default_value = rand_color_vector()
+    # Set strength
+    emission_node.inputs[1].default_value = REFLECTOR_STRENGTH
+    assign_node_to_output(emissive_material, emission_node)
+    assign_material(plane, emissive_material)
+
+# Tilt one of the reflectors
+plane2.rotation_euler.z += math.radians(90)
+
+# Add other elements
+for index in range(0, int(PROPS_NUMBER)):
+    bpy.ops.mesh.primitive_cube_add(location=rand_location(),radius=rand_scale(), rotation=rand_rotation())
+    if index == 0:
+        object_name = 'Cube'
+    elif index > 9:
+        object_name = 'Cube.0' + str(index)
+    elif index > 99:
+        object_name = 'Cube.' + str(index)
+    else:
+        object_name = 'Cube.00' + str(index)
+    object = bpy.data.objects[object_name]
+    new_material = create_cycles_material()
+    assign_random_texture_to_material(new_material)
+    assign_material(object, new_material)
+
+for index in range(0, int(PROPS_NUMBER)):
+    bpy.ops.mesh.primitive_circle_add(location=rand_location(),radius=rand_scale(), rotation=rand_rotation())
+    if index == 0:
+        object_name = 'Circle'
+    elif index > 9:
+        object_name = 'Circle.0' + str(index)
+    elif index > 99:
+        object_name = 'Circle.' + str(index)
+    else:
+        object_name = 'Circle.00' + str(index)
+    object = bpy.data.objects[object_name]
+    new_material = create_cycles_material()
+    assign_random_texture_to_material(new_material)
+    assign_material(object, new_material)
+
+# Add background to world
+world = bpy.data.worlds[0]
+world.use_nodes = True
+world_node_tree = world.node_tree
+# code.interact(local=dict(globals(), **locals()))
+gradient_node = world_node_tree.nodes.new(type="ShaderNodeTexGradient")
+background_node = world_node_tree.nodes['Background']
+world_node_tree.links.new(gradient_node.outputs['Color'], background_node.inputs['Color'])
+gradient_node.gradient_type = 'EASING'
+
+# ------
+# Shoot
+# ------
+print('Rendering images with resolution: ' + str(context.scene.render.resolution_x) + ' x ' + str(context.scene.render.resolution_y))
+for index in range(0, int(shots_number)):
+    print("-------------------------- " + str(index) + " --------------------------")
+    rotate(model_object, index)
+    shoot(camera_object, model_object, output_name(index, model_path))
+
+print('FINISHED ¯\_(ツ)_/¯')

data/lib/glitch3d/objects/face.rb

@@ -0,0 +1,22 @@
+class Face
+  attr_accessor :v1, :v2, :v3
+
+  def initialize(v1, v2, v3)
+    @v1 = v1
+    @v2 = v2
+    @v3 = v3
+  end
+
+  def to_s
+    return nil unless !v1.nil? && !v2.nil? && !v3.nil?
+    "f #{v1.index} #{v2.index} #{v3.index}"
+  end
+
+  def rand_attr
+    [:v1, :v2, :v3].sample
+  end
+
+  def fuck(new_vertex)
+    send("#{rand_attr}=", new_vertex)
+  end
+end

data/lib/glitch3d/objects/vertex.rb

@@ -0,0 +1,55 @@
+class Vertex
+  attr_accessor :x, :y, :z, :index
+
+  def initialize(x, y, z, index)
+    @x = x
+    @y = y
+    @z = z
+    @index = index
+  end
+
+  def to_s
+    "v #{x} #{y} #{z}"
+  end
+
+  def rand_attr
+    [:x, :y, :z].sample
+  end
+
+  def rescale(offset)
+    [:x, :y, :z].each do |attr|
+      value = send(attr)
+      send("#{attr}=", value * 0.8)
+    end
+  end
+
+  def fuck
+    attr = rand_attr
+    send("#{attr}=", send(attr) + Glitch3d.rand_vertex_glitch_offset)
+  end
+
+  def max
+    [@x.abs, @y.abs].max.round
+  end
+
+  def self.boundaries(vertices_list)
+    [
+      [vertices_list.max_by(&:x).x.ceil, vertices_list.min_by(&:x).x.round],
+      [vertices_list.max_by(&:y).y.ceil, vertices_list.min_by(&:y).y.round],
+      [vertices_list.max_by(&:z).z.ceil, vertices_list.min_by(&:z).z.round]
+    ]
+  end
+
+  def self.rescale(vertices, offset)
+    vertices.each do |v|
+      v.rescale(offset)
+    end
+  end
+
+  # Pass functions like :negative? or :positive?
+  def self.subset(x:, y:, z:, vertex_list:)
+    vertex_list.select do |vertex|
+      vertex.x.send(x) && vertex.y.send(y) && vertex.y.send(z)
+    end
+  end
+end

data/lib/glitch3d/strategies/default.rb

@@ -0,0 +1,17 @@
+module Glitch3d
+  module Default
+    def alter_vertices(vertices_objects_array)
+      (VERTEX_GLITCH_ITERATION_RATIO * vertices_objects_array.size).to_i.times do |_|
+        random_element(vertices_objects_array).fuck
+      end
+      vertices_objects_array
+    end
+
+    def alter_faces(faces_objects_array, vertex_objects_array)
+      (FACE_GLITCH_ITERATION_RATIO * faces_objects_array.count).to_i.times do |_|
+        random_element(faces_objects_array).fuck(random_element(vertex_objects_array))
+      end
+      faces_objects_array
+    end
+  end
+end

data/lib/glitch3d/strategies/localized.rb

@@ -0,0 +1,25 @@
+module Glitch3d
+  module Localized
+    def alter_vertices(vertices_objects_array)
+      (VERTEX_GLITCH_ITERATION_RATIO * vertices_objects_array.size).to_i.times do |_|
+        random_element(target(vertices_objects_array)).fuck
+      end
+      vertices_objects_array
+    end
+
+    def alter_faces(faces_objects_array, vertices_objects_array)
+      (FACE_GLITCH_ITERATION_RATIO * faces_objects_array.count).to_i.times do |_|
+        random_element(faces_objects_array).fuck(random_element(target(vertices_objects_array)))
+      end
+      faces_objects_array
+    end
+
+    def selected_area(vertices_objects_array)
+      Vertex.subset(x: :negative?, y: :positive?, z: :zero?, vertex_list: vertices_objects_array)
+    end
+
+    def target(vertices_objects_array)
+      @target ||= selected_area(vertices_objects_array)
+    end
+  end
+end

data/lib/glitch3d/version.rb

@@ -0,0 +1,3 @@
+module Glitch3d
+  VERSION = "0.1.0"
+end

data/lib/glitch3d.rb

@@ -0,0 +1,137 @@
+require "glitch3d/version"
+require "glitch3d/objects/vertex"
+require "glitch3d/objects/face"
+require "glitch3d/strategies/default"
+require "glitch3d/strategies/localized"
+require "pry"
+
+module Glitch3d
+  VERTEX_GLITCH_ITERATION_RATIO = 0.001
+  VERTEX_GLITCH_OFFSET = 1
+
+  FACE_GLITCH_ITERATION_RATIO = 0.0
+  FACE_GLITCH_OFFSET = 0.5
+  BOUNDARY_LIMIT = 4 # Contain model within 2x2x2 cube
+
+  BLENDER_EXECUTABLE_PATH = ENV['BLENDER_EXECUTABLE_PATH'].freeze
+  RENDERING_SCRIPT_PATH = "lib/glitch3d/bpy/rendering.py".freeze
+
+  def process_model(source_file)
+    raise 'Set Blender executable path in your env variables before using glitch3d' unless BLENDER_EXECUTABLE_PATH.present?
+    args = Hash[ARGV.join(' ').scan(/--?([^=\s]+)(?:=(\S+))?/)]
+    self.class.include infer_strategy(args["mode"] || 'default')
+    @quality = args["quality"] || 'low'
+    source_file = source_file
+    base_file_name = source_file.gsub(/.obj/, '')
+    target_file = base_file_name + '_glitched.obj'
+    boundaries = create_glitched_file(glitch(read_source(source_file)), target_file)
+    render(target_file, boundaries, args["shots-number"] || 6) unless args["no-render"]
+  end
+
+  def infer_strategy(mode)
+    return Glitch3d::Default if mode.nil?
+    {
+      default: Glitch3d::Default,
+      localized: Glitch3d::Localized
+    }[mode.to_sym]
+  end
+
+  class << self
+    def rand_vertex_glitch_offset
+      rand(-VERTEX_GLITCH_OFFSET..VERTEX_GLITCH_OFFSET)
+    end
+  end
+
+  private
+
+  def read_source(path)
+    File.open(path, 'r') do |f|
+      source_file_content = f.readlines
+      vertices_list = build_vertices(source_file_content.select { |s| s[0..1] == 'v ' })
+      faces_list = build_faces(source_file_content.select { |s| s[0..1] == 'f ' }, vertices_list)
+      {
+        vertices: vertices_list,
+        faces: faces_list
+      }
+    end
+  end
+
+  def build_vertices(vertices_string_array)
+    vertices_list = []
+    vertices_string_array.each_with_index.map do |sv, i|
+      v = sv.split(' ')
+      vertices_list << Vertex.new(v[1].to_f, v[2].to_f, v[3].to_f, i)
+    end
+    vertices_list
+  end
+
+  def build_faces(faces_string_array, vertices_list)
+    faces_list = []
+    faces_string_array.map do |sf|
+      f = sf.split(' ')
+      next if f.length <= 3
+      faces_list << Face.new(
+                      vertices_list[f[1].to_i],
+                      vertices_list[f[2].to_i],
+                      vertices_list[f[3].to_i]
+                    )
+    end
+    faces_list
+  end
+
+  def glitch(file_hash_content)
+    {
+      vertices: alter_vertices(file_hash_content[:vertices]),
+      faces: 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)
+    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])
+    end
+    boundaries = Vertex.boundaries(content_hash[:vertices])
+    puts boundaries.to_s
+    File.open(target_file, 'w') do |f|
+      f.puts '# Data corrupted with glitch3D script'
+      f.puts '# Boundaries: ' +  boundaries.to_s
+      f.puts ''
+      f.puts 'g Glitch3D'
+      f.puts ''
+      f.puts content_hash[:vertices].map(&:to_s)
+      f.puts ''
+      f.puts content_hash[:faces].map(&:to_s).compact
+    end
+    boundaries
+  end
+
+  def rescale_needed?(boundaries)
+    boundaries.flatten.map(&:abs).max.abs > BOUNDARY_LIMIT
+  end
+
+  def render(file_path, boundaries, shots_number)
+    args = [
+      BLENDER_EXECUTABLE_PATH,
+      '-b',
+      '-P',
+      RENDERING_SCRIPT_PATH,
+      '--',
+      '-f',
+      file_path,
+      '-n',
+      shots_number.to_s,
+      '-m',
+      @quality
+    ]
+    unless system(*args)
+      fail 'Make sure Blender is correctly installed'
+    end
+  end
+end