def __init__(self, material='Default', explore_type='iterate', textParam=''):
self.material = material
# self.text = textParam
self.text = "MUSSA"
#self.deep_count=int(ExplorerConfig.objects.get(k__exact='deep_count').v)
self.deep = False
self.bake = "all"
self.DEFAULT_VIEW = "Render"
self.renderer = Renderer()
def request_images(params):
renderer = Renderer()
renderer.request_images(params)
def get_ready_images():
renderer = Renderer()
renderer.get_ready_images()
class Base:
"""
Explore parameter space
"""
def __init__(self, material='Default', explore_type='iterate', textParam=''):
self.material = material
# self.text = textParam
self.text = "MUSSA"
#self.deep_count=int(ExplorerConfig.objects.get(k__exact='deep_count').v)
self.deep = False
self.bake = "all"
self.DEFAULT_VIEW = "Render"
self.renderer = Renderer()
def get_random_items(self, product):
variants = product.get_random_variants(9)
print len(variants)
items = map(lambda x: x.get_item(), variants)
return self._make_res_from_items(items)
def _make_res_from_items(self, items):
textParams = []
materials = []
all_uuids = []
for i in range(len(items)):
try:
pp = str(items[i].textParam)
textParams.append(pp)
except:
try:
pp = items[i].textParam
textParams.append(pp)
except:
continue;
materials.append(items[i].material)
all_uuids.append(str(items[i].uuid))
return self._make_result(all_uuids, materials, textParams, -1)
def render_materials(self, parent_id, definition_id, text):
if parent_id == None:
root = None
definition = GhDefinition.objects.get(pk=definition_id)
else:
root = Item.objects.get(uuid=parent_id)
definition = root.definition
if definition.accepts_text_params == False:
text = ""
self.explore_type = 'iterate'
materials = map(lambda x: x.material.name, DefinitionMaterial.objects.filter(definition=definition))
(selected,params) = self._get_children_params(definition, root, -1, 'noop')
print materials
if (root != None) and (root.material != 'Default'):
selected = materials.index(root.material)
params = [params[0] for i in materials]
#print params
(all_uuids, todo_uuids, todo_params, todo_materials, todo_bases) = self._get_cached_items(definition, params, materials, text)
#print (all_uuids, todo_uuids, todo_params, todo_materials, todo_bases)
for i in range(len(todo_materials)):
base = None
if len(todo_bases)>0:
base = todo_bases[i]
explorer.tasks.send_jobs.apply_async(kwargs={'base_models': [base]}, args=[definition, [todo_uuids[i]], None, [todo_params[i]], todo_materials[i], 'iterate', text])
return self._make_result(all_uuids, materials, [text for i in range(len(all_uuids))], selected)
def _explore(self):
(selected,params) = self._get_children_params(self.definition, self.root, self.param_index, self.explore_type)
materials = [self.material for i in range(len(params))]
(all_uuids, todo_uuids, todo_params, todo_materials, todo_bases) = self._get_cached_items(self.definition, params, materials, self.text, param_index=self.param_index)
explorer.tasks.send_jobs.apply_async(kwargs={'base_models': todo_bases, 'param_index': self.param_index}, args=[self.definition, todo_uuids, self.root, todo_params, self.material, 'iterate', self.text])
return self._make_result(all_uuids, materials, [self.text for i in range(len(all_uuids))], selected)
def _get_cached_items(self, definition, params, materials, text, param_index=None):
all_uuids = []
todo_uuids = []
todo_params = []
todo_materials = []
todo_bases = []
cache_count = 0
view = self._get_view(definition, param_index)
if view == self.DEFAULT_VIEW:
view = ""
for p,m in zip(params, materials):
#param_key = self._item_param_hash(p, "", "","")
param_key = self._item_param_hash(p.values(), m, text,view)
cached = Item.objects.filter(param_hash = param_key, definition = definition)
if len(cached)>0 and (definition.use_cache==True):
cache_count += 1
if (cached[0].status == Item.ERROR):
continue
if (cached[0].status == Item.CREATED):
todo_uuids.append(cached[0].uuid)
todo_materials.append(m)
todo_params.append(p)
all_uuids.append(cached[0].uuid)
else:
if (definition.base_definition!=None):
#print definition.base_definition.id
param_key = self._item_param_hash(p.base_values(), "", "","")
print param_key
cached_base = Item.objects.filter(base_param_hash = param_key, definition = definition.base_definition, has_3dm=True)
if len(cached_base)>0:
print "Found"
print "%s" % cached_base[0].status
print "%s" % len(cached_base)
if(cached_base[0].status == Item.ERROR): continue
todo_bases.append(cached_base[0].uuid)
else:
continue
print "Not found"
new_uuid = str(uuid.uuid1())
todo_uuids.append(new_uuid)
todo_materials.append(m)
todo_params.append(p)
all_uuids.append(new_uuid)
logging.error("new all %s, todo %s, cached %s" % (len(materials), len(todo_uuids), cache_count))
return (all_uuids, todo_uuids, todo_params, todo_materials, todo_bases)
def _get_base_cache(self, definition, params):
param_key = self._item_param_hash(params, "", "", "")
cached = Item.objects.filter(base_param_hash = param_key, definition = definition)
return cached[0].uuid
def _item_param_hash(self, params, material, text, view):
#hacked_params = filter(lambda x: x.)
p = "".join(map(lambda x: ("%.2f" % x)[0:], params)) + material + text + view
return p
#comment
def explore(self, item_id, param_index, explore_type, text):
self.root = Item.objects.get(uuid=item_id)
self.param_index = int(param_index)
self.definition = self.root.definition
self.explore_type = explore_type
if self.definition.accepts_text_params == False:
text = ""
self.text = text
if self.deep:
return self._explore_deep()
else:
return self._explore()
def item_to_product(self, item):
base = None
if item.definition.base_definition != None:
base = self._get_base_cache(item.definition.base_definition, item.get_params().values())
job = self._prepare_job(item.definition, item.uuid + '_' + 'Render', item.get_params(), item.textParam,'Render', item.material, 350, base_model=base)
self.renderer.request_images_async([job])
jobs = []
for view_name in ["Top","Front"]:
jobs.append(self._prepare_job(item.definition, item.uuid + '_' + view_name, item.get_params(), item.textParam,view_name, item.material, 350, base_model=base))
self.renderer.request_images_async(jobs, countdown=1)
job = self._prepare_job(item.definition, item.uuid, item.get_params(), item.textParam,'Render', item.material, 180, base_model=base)
self.renderer.request_images_async([job])
def get_stl(self, item_id):
item = Item.objects.get(uuid=item_id)
job = self._prepare_job(item.definition, item.uuid+ '-sw', item.get_params(), item.textParam,"Render", item.material, 674, True)
self.renderer.request_images_async([job])
def _get_children_params(self, definition, root, param_index, explore_type ):
if explore_type=='noop' and root!=None:
children_params = [root.get_params()]
selected=-1
else:
(selected, children_params) = self._get_page_params(definition, root, param_index)
return (selected,children_params)
def _get_page_params(self, definition, root, param_index):
if root!=None:
parent_params = root.get_params()
else:
parent_params = definition.get_initial_params()
if param_index < 0:
return (-1,[parent_params])
db_param = DefinitionParam.objects.get(definition=definition,index=param_index)
param_values = db_param.get_values()
params_list = []
selected=-1
for i in range(len(param_values)):
param = param_values[i]
#params = list(parent_params)
params = parent_params.copy()
if params[param_index].value == param:
selected=i
params[param_index].value = param
params_list.append(params)
#for pp in params_list:
# for p in pp.params:
# print "%s %s" % (p.base.name, p.value)
return (selected,params_list)
def _get_initial_page_params(self, definition):
db_params = DefinitionParam.objects.filter(definition=definition, active=True).order_by('index')
return map(lambda x: x.get_initial_value(), db_params)
def _get_view(self, definition, param_index):
view = self.DEFAULT_VIEW
if (param_index!=None):
db_param = DefinitionParam.objects.get(definition=definition,index=param_index)
if db_param.rendering_view != None:
view = db_param.rendering_view
return view
def _send_jobs(self, definition, uuids, root, children_params, text, base_models=None, low_priority=False, get_stl=False, param_index=None):
jobs = []
base_model=None
view = self._get_view(definition, param_index)
for i in range(len(uuids)):
if(base_models!=None)and(len(base_models)>0):
base_model = base_models[i]
jobs.append(self._prepare_job(definition, uuids[i], children_params[i], text, view, self.material, low_priority=low_priority, get_stl=get_stl, base_model=base_model))
self.renderer.request_images(jobs)
for i in range(len(uuids)):
saved = Item.objects.filter(uuid=uuids[i])
if(len(saved)==0):
self._save_item(root, definition, children_params[i], True, uuids[i], self.material, text, view=view)
else:
saved[0].sent = True
saved[0].status = Item.SENT
saved[0].save()
def _uuid_to_url(self, item_uuid):
return "http://s3.amazonaws.com/%s_Bucket/%s.jpg" % (Site.objects.get(id=settings.SITE_ID).name, item_uuid)
def _prepare_job(self, definition, item_id, params, text, view_name, material, width=180, get_stl=False, low_priority=False, base_model=None):
job = {}
job['params'] = dict(zip(definition.param_names(), params.values()))
if (definition.accepts_text_params):
textToSend = "test"
if (text != None):
textToSend = text
job['params']['textParam'] = textToSend
job['item_id'] = item_id
job['bake'] = self.bake
job['operation'] = 'render_model'
job['width'] = width
job['height'] = width
job['gh_file'] = definition.file_name
job['scene'] = definition.scene_file
job['layer_name'] = material
job['view_name'] = view_name
job['getSTL'] = get_stl
job['low_priority'] = low_priority
if base_model!=None:
job['load_stl'] = base_model
return job
def _make_result(self, uuids, materials, textParams, selected):
def do(x):
return { "id": x[0], "image_url": self._uuid_to_url(x[0]), "index": x[1], "material": x[2], "text": x[3]}
return {'selected': selected, 'items': map(do, zip(uuids, range(len(uuids)), materials, textParams))}
def _save_item(self, parent, definition, params, sent, item_uuid, material, textParam, view=""):
if not(isinstance(params, list)):
params = params.values()
if view == self.DEFAULT_VIEW:
view = ""
param_hash = self._item_param_hash(params, material, textParam, view)
base_param_hash = self._item_param_hash(params, "", "", "")
if (sent == True):
status = Item.SENT
else:
status = Item.CREATED
old_items = Item.objects.filter(uuid=item_uuid)
if len(old_items)!=0:
old_items[0].status = status
old_items[0].save()
return old_items[0]
db_item = Item(base_param_hash=base_param_hash,param_hash=param_hash, selected=False, material = material, image_url=self._uuid_to_url(item_uuid), parent=parent, definition=definition, sent=sent, status=status,uuid=item_uuid, params=params, textParam=textParam)
db_item.save()
#db_item.set_params(params)
return db_item
def _copy_item(self, obj):
from copy import deepcopy
old_obj = deepcopy(obj)
old_obj.id = None
old_obj.selected = False
old_obj.parent = None
old_obj.uuid = str(uuid.uuid1())
old_obj.save()
return old_obj
def send_background_items(self, definition=None):
max_wait = 50
wait_count = self.renderer.get_lowpriority_wait_count(['vases','rings','cases','pendants'])
can_send = max_wait - wait_count
#print settings.CELERYBEAT_SCHEDULE
if definition!=None:
to_send = Item.objects.filter(sent=False, definition=definition)[:can_send]
else:
to_send = Item.objects.filter(sent=False)[:can_send]
print "Sending %s low priority jobs" % (len(to_send))
for i in range(len(to_send)):
print "%s %s" % (to_send[i].uuid,to_send[i].base_param_hash)
#print to_send[i].base_param_hash
self.material = to_send[i].material
to_send[i].has_3dm = True
to_send[i].save()
self._send_jobs(to_send[i].definition, [to_send[i].uuid], None, [to_send[i].get_params()], 0, "", get_stl=True, low_priority=True)
def preprocess_definition(self, definition):
db_params = DefinitionParam.objects.filter(definition=definition, active=True).order_by('index')
param_values = map(lambda x: x.get_values(), db_params)
print param_values
param_perms = all_params_perms(param_values)
#if (definition)##
#materials = map(lambda x: x.material.name, DefinitionMaterial.objects.filter(definition=definition))
materials = [definition.default_material.name]
print materials
for material in materials:
print material
#param_perms = itertools.product(param_values, repeat=len(param_names))
#print param_perms
for perm in param_perms:
print perm
item_uuid = str(uuid.uuid1())
self._save_item(None, definition, perm, False , item_uuid, material, "")
def process_ghx(self, definition):
self.renderer.adjust_ghx(definition.current_file_name, definition.scene_file)
# def _explore_deep(self):
# children = None
# for i in range(100):
# children = Item.objects.filter(parent__exact=self.root.id, parent_distance=self.distance)
# if children.count() >= self.page_size:
# break
# else:
# logging.warn('sleeping')
# time.sleep(0.1)
#
# explorer.tasks.send_missing_jobs.apply_async(args=[children], countdown=0)
# explorer.tasks.send_deep_jobs.apply_async(args=[children], countdown=1)
#
# self.root.selected=True
# self.root.save()
#
# uuids = map(lambda x: x.uuid, children)
# return self._make_result(uuids, [self.material for i in range(self.page_size)])
#
# def _send_missing_jobs(self, items):
# jobs=[]
# for item in items:
# if item.sent != True:
# item.sent=True
# item.save()
# logging.warn(item.uuid + 'missing!!!!')
# jobs.append(self._prepare_job(item.definition, item.uuid, item.params, item.textParam, "Render", item.material))
# self.renderer.request_images(jobs)
#
# def _send_deep_jobs(self, items):
# for item in items:
# for distance in self.distances.keys():
# uuids = map(lambda x: str(uuid.uuid1()), range(self.page_size))
# self._send_jobs(item.definition, uuids, item, self.deep_count, distance)
#
#class Remember(Base):
# def stam(self):
# pass