def __init__(self, parameters): super().__init__(parameters) self.SUPPORTED_TYPES = {'man', 'woman', 'cat'} self._set_default_type_if_needed('human') chosen_type = self._get_chosen_type() face_params = self.parameters face_params[EP.ASPECT_RATIO] = 'fit' if chosen_type is None: print('{} head type not implemented!'.format( self.parameters[EP.TYPE])) elif chosen_type == 'man': self.parts.append( Part(entity=Face(face_params), relative_position=RelativePosition(top=0.05))) self.parts.append( Part(entity=Hair(self.parameters), relative_position=RelativePosition(top=0.0, bottom=0.35, left=0.1, right=0.9))) elif chosen_type == 'woman': self.parts.append( Part(entity=Face(face_params), relative_position=RelativePosition(top=0.05, bottom=0.9))) self.parts.append( Part(entity=Hair(self.parameters), relative_position=RelativePosition())) elif chosen_type == 'cat': self.parts.append(Part(entity=Face(face_params)))
def __init__(self, xy): self.parts = [] self.backup = [] self.sensors = [] self.colliding = [] self.network = network() parts = self.parts backup = self.backup self.locked = [0, 0, 0, 0, 0, 0, 0, 0, 0] # add the head and body parts parts.append(Part(0, xy[0], xy[1], True)) parts.append(Part(0, 0, 0, False)) parts.append(Part(0, 0, 0, False)) # Load the image files parts[0].loadImage("image_resources/body.png") parts[1].loadImage("image_resources/body.png") parts[2].loadImage("image_resources/head.png") # Set the constraints of the body parts so that the agents cannot fold in on themselves parts[0].setConstraint(((parts[1].getRotation() - 90) % 360, (parts[1].getRotation() + 90) % 360)) parts[1].setConstraint(((parts[0].getRotation() - 90) % 360, (parts[0].getRotation() + 90) % 360)) parts[2].setConstraint(((parts[1].getRotation() - 90) % 360, (parts[1].getRotation() + 90) % 360)) # Body parts and heads weight parts[0].setWeight(23.44) parts[1].setWeight(11.72) parts[2].setWeight(8.24) # Add the leg parts for i in range(0, 2): parts.append(part(310, 0, 0, False)) parts.append(part(50, 0, 0, False)) parts.append(part(50, 0, 0, False)) parts.append(part(0, 0, 0, False)) parts.append(part(0, 0, 0, False)) parts.append(part(0, 0, 0, False)) for l in range(3, 15): # Load the image files and set the constraints parts[l].loadImage("image_resources/leg.png") parts[l].setWeight(0.66) if l % 6 < 3: parts[l].setConstraint(((parts[l].getRotation() - 90) % 360, (parts[l].getRotation() + 90) % 360)) else: parts[l].setConstraint((0, 360)) # Initialise the backup storage for the parts information with 0 values for k in range(0, 15): backup.append(part(0, 0, 0, False)) self.colliding.append(False) # Backup objects that can be used to revert object overlaps and handle collisions self.objects = [] self.setSensors()
def __init__(self): # The robotic parts are seperated from the obstacles so that the state could comprise of only the robotic_parts, # since these are the only entities that are affected by change, unlike the obstacles which are stationery. self.dimensions = [random.randint(1, 100), random.randint(1, 100)] self.obstacles = [0] * random.randint( 1, self.dimensions[0] * self.dimensions[1]) self.robotic_parts = [0] * random.randint( 1, self.dimensions[0] * self.dimensions[1] - len(self.obstacles)) # Generate a list of random nums used to allocate positions of robotic parts and obstacles random_cells = random.sample( xrange(self.dimensions[0] * self.dimensions[1]), len(self.robotic_parts) + len(self.obstacles)) # Mapping the grid indexes to coordinates for both the parts and obstacles i = 0 while i < len(self.robotic_parts): self.robotic_parts[i] = Part([ random_cells[i] / self.dimensions[1], random_cells[i] % self.dimensions[1] ]) # i = i + 1 i = 0 while i < len(self.obstacles): self.obstacles[i] = [ random_cells[i + len(self.robotic_parts)] / self.dimensions[1], random_cells[i + len(self.robotic_parts)] % self.dimensions[1] ] i = i + 1 # Populating the adjacency lists for each of the robotic parts coord_transformations = [[1, 0], [-1, 0], [0, 1], [0, -1]] for part in self.robotic_parts: # Perform a bfs on each of the robotic parts to create its adjacency list. parts = Queue() parts.put(part) while not parts.empty(): curr_part = parts.get_nowait() # Coordinates of the current part x = curr_parts.coords[0] y = curr_part.coords[1] # Check for parts in the 4 adjacent cells for i in xrange(4): is_occupied = check_occupation([ x + coord_transformations[i][0], y + coord_transformations[i][1] ]) if is_occupied != False: q.put(self.robotic_parts[is_occupied]) part.adj_list.add( is_occupied ) # Add the index of the part occupying the cell
def addPart(self, name): part = Part() part.name = name part.src = name.replace(" ", "").lower() + ".md" self._parts.append(part) with open(os.path.join(self.source_path, "parts", part.src), "w") as f: f.write("") self.save()
def __init__(self, parameters): super().__init__(parameters) self.parts.append( Part(entity=Oval(parameters), relative_position=RelativePosition(left=0, top=0, right=1, bottom=1)))
def parts(self): '''Return a list of part visualizations.''' parts = [] for index, data in enumerate(self.data.parts): # create part part = Part(data, index, self.palette, self.show_dynamic, self.show_register) # visualize part and keep the result parts.append(part.visualize()) return parts
def __init__(self, parameters): super().__init__(parameters) self.SUPPORTED_TYPES = {'human'} self._set_default_type_if_needed('human') chosen_type = self._get_chosen_type() if chosen_type is None: print('arms of {} not implemented!'.format(self.parameters[EP.TYPE])) elif chosen_type == 'human': self.parts.append(Part(entity=Oval(self.parameters), relative_position=RelativePosition()))
def __init__(self, parameters): super().__init__(parameters) self.SUPPORTED_TYPES = {'human'} self._set_default_type_if_needed('human') chosen_type = self._get_chosen_type() if chosen_type == 'human': self.parts.append( Part(entity=Oval({EP.ASPECT_RATIO: Eye.ASPECT_RATIO['human']}), relative_position=RelativePosition(left=0, top=0, right=1, bottom=1))) self.parts.append( Part(entity=Oval({EP.ASPECT_RATIO: 1.0}), relative_position=RelativePosition(top=0, bottom=1, left=0.25, right=0.75)))
def __init__(self, parameters): parameters[EP.TYPE] = 'woman' super().__init__(parameters) self._change_default_aspect_ratio_to_value(0.7) self.parts.append( Part(Head(self.parameters), relative_position=RelativePosition(bottom=1 / 7.5, left=0.38, right=0.62))) self.parts.append( Part(Torso(self.parameters), relative_position=RelativePosition(left=0.2, right=0.8, top=1 / 7.5, bottom=4 / 7.5))) self.add_part(Leg, left=0.38, right=0.43, top=4 / 7.5) self.add_part(Leg, left=0.58, right=0.63, top=4 / 7.5) self.add_part(Arm, left=0.4, right=0.41, top=1 / 7.5, bottom=4 / 7.5) self.add_part(Arm, left=0.57, right=0.6, top=1 / 7.5, bottom=4 / 7.5)
def loadJSONRegistry(): loadedRegistry = {} with open('registry.json') as json_file: existingParts = json.load(json_file) for jsonPart in existingParts['Parts']: partName = jsonPart['Part Name'] partType = jsonPart['Type'] partVolume = jsonPart['Volume'] newPart = Part(partName, partType, partVolume) loadedRegistry[partName] = newPart return loadedRegistry
def __init__(self): """ Constructor """ self.title = "Untitled" self.author = "Unauthored" self.parts = [] # Add a default part self.parts.append(Part()) # These events are global in scope self.globalEvents = []
def __init__(self, partsDescriptionDir = 'PartDescriptionFiles'): self._parts = {} """Parts lilsted by name.""" for f in os.listdir(partsDescriptionDir): f = os.path.join(partsDescriptionDir, f) if not os.path.isfile(f): continue if not f.lower().endswith('.xml'): continue part = Part(f) name = part.getName() if name in self._parts: raise PgmError("Duplicate part names %s" % name) self._parts[part.getName()] = part
def __init__(self, params): super().__init__(params) self.SUPPORTED_TYPES = {'human'} self._set_default_type_if_needed('human') chosen_type = self._get_chosen_type() if chosen_type == 'human': self.parts.append( Part( Triangle({ EP.TYPE: 'human_nose', EP.ASPECT_RATIO: self.parameters[EP.ASPECT_RATIO] }), RelativePosition())) else: 'TODO'
def create_part(self, part_name, model, dimensionality, part_type): self.write('#PART\n') part = Part(part_name, model, dimensionality, part_type) part_name = part.get_part_name() dimensionality = part.get_dimensionality() part_type = part.get_part_type() model_name = model.get_model_name() self.write(part_name + "=" + model_name + ".Part(dimensionality =" + dimensionality + " , name= '" + part_name + "' , type = " + part_type + ")\n") self.write('f, e = ' + part_name + '.faces, ' + part_name + '.edges #getting the edges and faces of the part\n') model.add_part(part) self.seperate_sec() return part
def handle_f3(self): """ Format 3 ReferenceDesignators;MPN;Manufacturer """ bom_info = self.input_line.split(';') if not len(bom_info) == 3: return None part = Part(mpn=bom_info[1], reference_designators=bom_info[0], manufacturer=bom_info[2]) return part
def add_part(self, part_type, top=0.0, bottom=1.0, left=0.0, right=1.0, aspect_ratio='default'): parameters = deepcopy(self.parameters) parameters[EP.ASPECT_RATIO] = aspect_ratio self.parts.append( Part(entity=part_type(parameters=parameters), relative_position=RelativePosition(left=left, right=right, top=top, bottom=bottom)))
def __init__(self, element, server): self.server = server self.element = element self.part = Part(element.find('.Part'), self.server) try: self.videoFrameRate = element.attrib['videoFrameRate'] self.videoCodec = element.attrib['videoCodec'] self.container = element.attrib['container'] self.bitrate = int(element.attrib['bitrate']) self.height = int(element.attrib['height']) self.width = int(element.attrib['width']) self.videoResolution = element.attrib['videoResolution'] self.audioCodec = element.attrib['audioCodec'] except KeyError as e: print "Missing key in element: ", e.message
def handle_f1(self): """ Format 1 MPN:Manufacturer:ReferenceDesignators TSR-1002:Panasonic:A1,D2 """ bom_info = self.input_line.split(':') if not len(bom_info) == 3: return None part = Part(mpn=bom_info[0], manufacturer=bom_info[1], reference_designators=bom_info[2]) return part
def handle_f2(self): """ Format 2 Manufacturer -- MPN:ReferenceDesignators Panasonic -- TSR-1002:A1 """ bom_info = self.input_line.split('--') mpn_rd = bom_info[1].split(':') if not (len(bom_info) == 2 and len(mpn_rd) == 2): return None part = Part(mpn=mpn_rd[0], manufacturer=bom_info[0], reference_designators=mpn_rd[1]) return part
def set_filename(self): filenames_str = filedialog.askopenfilenames(filetypes=[("*.STL", "*.stl")]) print("filenames_str {0}".format(filenames_str)) print("Adding STL files:") for stl_file in list(filenames_str): print("- {0} ".format(stl_file)) part_name = stl_file.split("/")[-1].replace(".STL", "") if (part_name in self.order.parts.keys()): print("!!!! Warning part already in order !!!!") part = Part(part_name) part.read_mesh(stl_file) part.calc_props() self.order.parts[part_name] = part #print ("filenames {0}".format(filenames_str.splitlist())) self.write_stls()
def __init__(self, xy): self.sensors = [] self.colliding = [] self.network = Network() self.locked = [0, 0, 0, 0, 0, 0, 0, 0, 0] self.cog = (0, 0) self.counter = 0 self.xy = xy self.reset(False, 0, True) # Initialise the backup storage for the parts information with 0 values self.backup = [] for k in range(0, 15): self.backup.append(Part(0, 0, 0, False)) self.colliding.append(False) # Backup objects that can be used to revert object overlaps and handle collisions self.objects = []
def reset(self, stage, score, init): parts = [] # add the head and body parts parts.append(Part(0, self.xy[0], self.xy[1], True)) parts.append(Part(0, 0, 0, False)) parts.append(Part(0, 0, 0, False)) # Load the image files parts[0].loadImage("image_resources/body.png") parts[1].loadImage("image_resources/body.png") parts[2].loadImage("image_resources/head.png") # Body parts and heads weight parts[0].setWeight(23.44) parts[1].setWeight(11.72) parts[2].setWeight(8.24) # Add the leg parts for i in range(0, 2): parts.append(Part(310, 0, 0, False)) parts.append(Part(50, 0, 0, False)) parts.append(Part(50, 0, 0, False)) parts.append(Part(0, 0, 0, False)) parts.append(Part(0, 0, 0, False)) parts.append(Part(0, 0, 0, False)) for l in range(3, 15): # Load the image files and set the constraints parts[l].loadImage("image_resources/leg.png") parts[l].setWeight(0.66) self.parts = parts self.centerOfGravity() self.setSensors() self.setConstraints() if not init: if stage: self.network.nextGame(self.getCog()[0] - score) else: self.network.nextGameCompleted(self.getCog()[0] - score)
def __init__(self, avid): logging.info('downloading post info ...') initinfo = utility.getPostInfo(str(avid)) if initinfo == None: logging.error('Failed to get video info. Maybe non-exists.') quit() self.avid = initinfo['aid'] self.title = initinfo['videoData']['title'] self.desc = initinfo['videoData']['desc'] self.duration = utility.durationToTime( initinfo['videoData']['duration']) self.pubdate = time.localtime(initinfo['videoData']['pubdate']) self.authorName = initinfo['upData']['name'] self.authorUID = initinfo['upData']['mid'] self.parts = [] for p in initinfo['videoData']['pages']: part = Part(p['cid'], self.title, p['part'], utility.durationToTime(p['duration'])) self.parts.append(part)
def custom_part_formatter(part_list, record_count): """ Requires a list of Part Objects and Returns custom json output. Requires list of records to return. """ formatted_parts = [] part_group_keys = list(set([part.part_key for part in part_list])) for part_key in part_group_keys: count = 0 reference_designator_all = [] for part in part_list: if part_key == part.part_key: count += 1 reference_designator_all.extend(part.reference_designators) manufacturer = part.manufacturer mpn = part.mpn # remove dupes. reference_designator_all = list(set(reference_designator_all)) new_part = Part( mpn=mpn, manufacturer=manufacturer, reference_designators=reference_designator_all, ) # override the num occurences with current part count new_part.num_occurences = count formatted_parts.append(new_part) # sorts the list by num occurences, and num reference designators descending. # filters by number of records requested when calling custom_part_formatter() newlist = sorted([part.as_dict() for part in formatted_parts], key=lambda k: (k['NumOccurences'], len(k['ReferenceDesignators'])), reverse=True)[:record_count] return newlist
def __init__(self, backup, position, step): self.array = [] self.training_step = step + 1 self.init = False self.given = False # If this is an agents backup store default values for all parts if backup: for k in range(0, 15): self.array.append(Part(0, 0)) # Otherwise spawn agent in a random position else: # Initialise the body and head of the agent random = randint(-30, 30) # The back of the agent is the heaviest so that it does ot topple forwards if self.training_step == 1: self.array.append( Part(random + randint(-89, 89), 50, 23.44, position)) self.array.append(Part(random, 50, 11.72)) self.array.append(Part(random + randint(-89, 89), 50, 8.24)) else: self.array.append(Part(0, 50, 23.44, position)) self.array.append(Part(0, 50, 11.72)) self.array.append(Part(0, 50, 8.24)) # Load the head and bodies image files self.array[0].load_image("image_resources/body.png") self.array[1].load_image("image_resources/body.png") self.array[2].load_image("image_resources/head.png") # Initialise the legs of the agent for i in range(0, 2): random_values = [randint(0, 360), randint(-90, 90)] # The legs on each side of the agent should have matching rotations # The weight of each leg is 0.66 * 2 (Since each leg is made of 2 parts) self.array.append(Part(random_values[0], 12, 0.66)) self.array.append(Part(random_values[0], 12, 0.66)) self.array.append(Part(random_values[0], 12, 0.66)) self.array.append( Part(random_values[0] + random_values[1], 12, 0.66)) self.array.append( Part(random_values[0] + random_values[1], 12, 0.66)) self.array.append( Part(random_values[0] + random_values[1], 12, 0.66)) # Load the image files for the legs for j in range(3, 15): self.array[j].load_image("image_resources/leg.png") # Set each parts position and constraints self.set_positions(position) self.set_constraints()
def load_item(json_string, object_dec, json_filename): s = json_string.read() jdict = json.loads(s, object_hook=object_dec.decode_component) jdict.__dict__['json_id'] = json_filename item = Part(**(jdict.to_dict())) return item
def addToHead(self, location): self.body.addBegin((Part(self.surface, location, self.color, self.size)))
def createPart(self, loc): return Part(self.surface, loc, self.color, self.size)
) ap.add_argument( '-c', '--cid-mode', action='store_true', help= 'Specify videos by cid rather than avid. Argument "avid" will be regarded as cid. Use space to seperate multiple cids.' ) args = ap.parse_args() if not args.cid_mode: for avid in args.avid: if avid.startswith('av'): avid = avid[2:] logging.info('Downloading post av%s' % avid) post = Post(avid) post.showInfo() if args.download: if args.part == -1: logging.info('Downloading post: %s (%d parts in total)' % (post.title, len(post.parts))) for p in post.parts: p.download() logging.info('Download finished!') else: post.parts[args.part - 1].download() else: if args.download: for cid in args.avid: p = Part(cid, str(cid), str(cid), None) p.download()
def __init__(self, parameters): super().__init__(parameters) self.SUPPORTED_TYPES = {'man', 'woman'} self._set_default_type_if_needed('human') chosen_type = self._get_chosen_type() if chosen_type is None: print('{} hair type not implemented!'.format( self.parameters[EP.TYPE])) elif chosen_type == 'man': self.parts.append( Part(entity=Oval({ EP.LINE_THICKNESS: -1, EP.COLOR: self.parameters[EP.COLOR] }), relative_position=RelativePosition(left=0.0, right=1.0, top=0.0, bottom=0.8))) self.parts.append( Part(entity=Oval({ EP.LINE_THICKNESS: -1, EP.COLOR: self.parameters[EP.COLOR] }), relative_position=RelativePosition(left=0.0, right=0.1, top=0.0, bottom=1.0))) self.parts.append( Part(entity=Oval({ EP.LINE_THICKNESS: -1, EP.COLOR: self.parameters[EP.COLOR] }), relative_position=RelativePosition(left=0.9, right=1.0, top=0.0, bottom=1.0))) elif chosen_type == 'woman': self.parts.append( Part(entity=Oval({ EP.LINE_THICKNESS: -1, EP.COLOR: self.parameters[EP.COLOR] }), relative_position=RelativePosition(left=0.0, right=1.0, top=0.0, bottom=0.2))) self.parts.append( Part(entity=Oval({ EP.LINE_THICKNESS: -1, EP.COLOR: self.parameters[EP.COLOR] }), relative_position=RelativePosition(left=0.0, right=0.1, top=0.0, bottom=1.0))) self.parts.append( Part(entity=Oval({ EP.LINE_THICKNESS: -1, EP.COLOR: self.parameters[EP.COLOR] }), relative_position=RelativePosition(left=0.9, right=1.0, top=0.0, bottom=1.0)))