def _get_seed_point_index(self, hatch_tags: Tags) -> int: try: seed_count_index = hatch_tags.tag_index(98) # find index of 'Number of seed points' except DXFValueError: raise DXFStructureError("HATCH: Missing required DXF tag 'Number of seed points' (code=98).") try: first_seed_point_index = hatch_tags.tag_index(10, seed_count_index + 1) except DXFValueError: raise DXFStructureError("HATCH: Missing required DXF tags 'seed point X value' (code=10).") return first_seed_point_index
def from_tags(tags: Tags) -> 'GradientData': gdata = GradientData() try: index = tags.tag_index( 450) # required tag if hatch has gradient data except DXFValueError: raise DXFStructureError( "HATCH: Missing required DXF tag for gradient data (code=450)." ) # if tags[index].value == 0 hatch is a solid ???? first_color_value = True for code, value in tags[index:]: if code == 460: gdata.rotation = (value / math.pi) * 180. # radians to grad elif code == 461: gdata.centered = value elif code == 452: gdata.one_color = value elif code == 462: gdata.tint = value elif code == 470: gdata.name = value elif code == 421: # code == 63 color as ACI, can be ignored if first_color_value: gdata.color1 = int2rgb(value) first_color_value = False else: gdata.color2 = int2rgb(value) return gdata
def _setup_paths(self, tags: Tags) -> List['PolylinePath']: paths = [] try: self.start_index = tags.tag_index( 91) # code 91=Number of boundary paths (loops) n_paths = tags[self.start_index].value except DXFValueError: raise DXFStructureError( "HATCH: Missing required DXF tag 'Number of boundary paths (loops)' (code=91)." ) self.end_index = self.start_index + 1 # + 1 for Tag(91, Number of boundary paths) if n_paths == 0: # created by ezdxf from template without path data return paths all_path_tags = tags.collect_consecutive_tags(PATH_CODES, start=self.start_index + 1) self.end_index = self.start_index + len( all_path_tags) + 1 # + 1 for Tag(91, Number of boundary paths) # end_index: stored for Hatch._set_boundary_path_data() grouped_path_tags = group_tags(all_path_tags, splitcode=92) for path_tags in grouped_path_tags: path_type_flags = path_tags[0].value is_polyline_path = bool(path_type_flags & 2) path = PolylinePath.from_tags( path_tags) if is_polyline_path else EdgePath.from_tags( path_tags) path.path_type_flags = path_type_flags paths.append(path) return paths
def extract_block_attribs(data: Tags) -> List[AttribData]: def store_attrib(): attribs.append( AttribData( collector.get(330, '0'), # ATTDEF handle collector.get(177, 0), # ATTDEF index collector.get(44, 1.0), # ATTDEF width collector.get(302, ''), # ATTDEF text (content) )) collector.clear() attribs = [] try: start = data.tag_index(330) except const.DXFValueError: return attribs end = start collector = dict() for code, value in data.collect_consecutive_tags({330, 177, 44, 302}, start): end += 1 if code == 330 and len(collector): store_attrib() collector[code] = value if len(collector): store_attrib() # Remove processed tags: del data[start:end] return attribs
def extract_arrow_heads(data: Tags) -> List[ArrowHeadData]: def store_head(): heads.append( ArrowHeadData( collector.get(94, 0), # arrow head index collector.get(345, '0'), # arrow head handle )) collector.clear() heads = [] try: start = data.tag_index(94) except const.DXFValueError: return heads end = start collector = dict() for code, value in data.collect_consecutive_tags({94, 345}, start): end += 1 collector[code] = value if code == 345: store_head() # Remove processed tags: del data[start:end] return heads
def store_acad_xdata(tags: Tags): try: index = tags.tag_index(291) except IndexError: return None else: # store tags after 291 index += 1 xdata = tags[index:] del tags[index:] # remove xdata from subclass return xdata
def load_gradient(self, tags: Tags) -> Tags: try: index = tags.tag_index(450) except const.DXFValueError: # no gradient data present return tags # gradient data is always at the end of the AcDbHatch subclass self.gradient = Gradient.load_tags(tags[index:]) # remove gradient data del tags[index:] return tags
def load_pattern(self, tags: Tags) -> Tags: try: index = tags.tag_index(78) # code 78=Number of patter definition lines except const.DXFValueError: # no pattern definition lines found return tags pattern_tags = tags.collect_consecutive_tags(PATTERN_DEFINITION_LINE_CODES, start=index + 1) self.pattern = Pattern.load_tags(pattern_tags) # delete pattern data including length tag 78 del tags[index: index + len(pattern_tags) + 1] return tags
def load_seeds(self, tags: Tags) -> Tags: try: start_index = tags.tag_index(98) except const.DXFValueError: return tags seed_data = tags.collect_consecutive_tags({98, 10, 20}, start=start_index) # remove seed data from tags del tags[start_index: start_index + len(seed_data) + 1] # just process vertices with group code 10 self.seeds = [value for code, value in seed_data if code == 10] return tags
def load_paths(self, tags: Tags) -> Tags: # find first group code 91 = count of loops, Spline data also contains group code 91! try: start_index = tags.tag_index(91) except const.DXFValueError: raise const.DXFStructureError( "HATCH: Missing required DXF tag 'Number of boundary paths (loops)' (code=91).") path_tags = tags.collect_consecutive_tags(PATH_CODES, start=start_index + 1) if len(path_tags): self.paths = BoundaryPaths.load_tags(path_tags) end_index = start_index + len(path_tags) + 1 del tags[start_index: end_index] return tags
def load_proxy_data(tags: Tags, length_code: int, data_code: int = 310) -> Optional[bytes]: try: index = tags.tag_index(length_code) except const.DXFValueError: return None binary_data = [] for code, value in tags[index + 1:]: if code == data_code: binary_data.append(value) else: break # at first tag with group code != data_code return b"".join(binary_data)
def _setup_pattern_lines(self, tags: Tags) -> List['PatternDefinitionLine']: try: self.existing_pattern_start_index = tags.tag_index(78) # code 78=Number of patter definition lines except DXFValueError: # no pattern definition lines found self.existing_pattern_start_index = 0 self.existing_pattern_end_index = 0 return [] all_pattern_tags = tags.collect_consecutive_tags(PATTERN_DEFINITION_LINE_CODES, start=self.existing_pattern_start_index + 1) self.existing_pattern_end_index = self.existing_pattern_start_index + len( all_pattern_tags) + 1 # + 1 for Tag(78, Number of boundary paths) # existing_pattern_end_index: stored for Hatch._set_pattern_data() grouped_line_tags = group_tags(all_pattern_tags, splitcode=53) return [PatternDefinitionLine.from_tags(line_tags) for line_tags in grouped_line_tags]
def load_arrow_heads(data: Tags) -> List[ArrowHeadData]: def store_head(): heads.append(ArrowHeadData( collector.get(94, 0), # arrow head index collector.get(345, '0'), # arrow head handle )) collector.clear() heads = [] try: start = data.tag_index(94) except const.DXFValueError: return heads collector = dict() for code, value in data.collect_consecutive_tags({94, 345}, start): collector[code] = value if code == 345: store_head() return heads