def create_background_and_frame(self, border, background, layout_item_base_element): """ This function creates background and frame properties if these values exist. :param border: the border_object as arcObject :param background: the background_object as arcObject :param layout_item_base_element: the item layout in the DOM """ frame_border_symbol = change_interface( border, ArcGisModules.module_carto.ISymbolBorder) frame_background_symbol = change_interface( background, ArcGisModules.module_carto.ISymbolBackground) if frame_border_symbol: layout_item_base_element.setAttribute("frame", "true") LayoutItem.create_frame_element( self, layout_item_base_element, frame_border_symbol.LineSymbol.Color.RGB) layout_item_base_element.setAttribute( "outlineWidthM", "{},pt".format(frame_border_symbol.LineSymbol.Width)) else: layout_item_base_element.setAttribute("frame", "false") if frame_background_symbol: layout_item_base_element.setAttribute("background", "true") LayoutItem.create_background_element( self, layout_item_base_element, frame_background_symbol.FillSymbol.Color.RGB) else: layout_item_base_element.setAttribute("background", "false")
def create_graduated_colors_element(base, renderer, symbols): """This creates the graduated-colors-renderer-element in the DOM :param base: is the self of the renderer object :param renderer: is the renderer-element in the DOM :param symbols: is the list of used symbols of the renderer """ renderer.setAttribute("type", "graduatedSymbol") renderer.setAttribute("symbollevels", "0") renderer.setAttribute("graduatedMethod", "GraduatedColor") renderer.setAttribute("attr", base.layer.symbology.valueField) graduated_layer = change_interface( base.arcLayer, ArcGisModules.module_carto.IGeoFeatureLayer) graduated_renderer = change_interface( graduated_layer.Renderer, ArcGisModules.module_carto.IClassBreaksRenderer) for each in range(0, base.layer.symbology.numClasses): symbols.append(graduated_renderer.Symbol[each]) ranges_element = base.xml_document.createElement("ranges") renderer.appendChild(ranges_element) for index, (label, value) in enumerate( zip(base.layer.symbology.classBreakLabels, base.layer.symbology.classBreakValues)): range_element = base.xml_document.createElement("range") range_element.setAttribute("render", "true") range_element.setAttribute("symbol", str(index)) range_element.setAttribute("label", label) range_element.setAttribute("lower", str(value)) range_element.setAttribute( "upper", str(base.layer.symbology.classBreakValues[index + 1])) ranges_element.appendChild(range_element)
def create_line_element_content(self, line_element_layout): """ This function creats the Line-item specific content :param line_element_layout: the layout element in the DOM """ arcpy_item = LayoutItem.get_arcpy_layout_element(self, self.line_object) LineElement.set_size_and_position(self, line_element_layout, arcpy_item) element_geometry = change_interface(self.line_object, ArcGisModules.module_carto.IElement).Geometry poly_ine_symbol = change_interface(element_geometry, ArcGisModules.module_geometry.IPolyline5) point_collection = change_interface(poly_ine_symbol, ArcGisModules.module_geometry.IPointCollection) line_element_layout.setAttribute('type', '65645') line_element_layout.setAttribute("frame", "false") line_element_layout.setAttribute("background", "false") LineElement.set_uuid_attributes(arcpy_item.name, line_element_layout) symbol = self.line_object.Symbol symbol_properties = {} SymbolPropertiesProvider.get_line_properties(symbol_properties, symbol) SimpleSymbol.create_simple_symbol(self.dom, line_element_layout, symbol_properties, 1, '1') LineElement.create_nodes(self, line_element_layout, point_collection, arcpy_item)
def create_unique_values_element(base, renderer, symbols): """This creates the unique-value-renderer-element in the DOM :param base: is the self of the renderer object :param renderer: is the renderer-element in the DOM :param symbols: is the list of used symbols of the renderer """ geo_feature_layer = change_interface(base.arcLayer, ArcGisModules.module_carto.IGeoFeatureLayer) unique_renderer = change_interface(geo_feature_layer.Renderer, ArcGisModules.module_carto.IUniqueValueRenderer) renderer.setAttribute("type", "categorizedSymbol") renderer.setAttribute("attr", unique_renderer.Field[0]) categories_element = base.xml_document.createElement("categories") renderer.appendChild(categories_element) last_index = unique_renderer.ValueCount for index in range(0, last_index + 1): value = "" if index == last_index else unique_renderer.Value[index] symbols.append( unique_renderer.DefaultSymbol if index == last_index else unique_renderer.Symbol[value] ) category_element = base.xml_document.createElement("category") category_element.setAttribute("render", "true") category_element.setAttribute("symbol", str(index)) category_element.setAttribute("value", value) category_element.setAttribute("label", unique_renderer.DefaultLabel if index == last_index else unique_renderer.Label[value] ) categories_element.appendChild(category_element)
def get_layout_item_type(layout_item, properties=None): """ This function returns the item-type from an arcObject :param layout_item: the item as ArcObject :param properties: if properties have been collected they can be declared :return: the type of the item as string """ if properties is None: properties = LayoutItemPropertiesProvider.get_item_properties( layout_item) layout_item_type = properties.Type if layout_item_type == u'Map Surround Frame' or layout_item_type == u'Kartenumgebungsrahmen': map_surround_frame = change_interface( layout_item, ArcGisModules.module_carto.IMapSurroundFrame) legend = change_interface(map_surround_frame.MapSurround, ArcGisModules.module_carto.ILegend2) north_arrow = change_interface( map_surround_frame.MapSurround, ArcGisModules.module_carto.INorthArrow) scale_bar = change_interface(map_surround_frame.MapSurround, ArcGisModules.module_carto.IScaleBar) if legend: layout_item_type = u'Legend' if north_arrow: layout_item_type = u'North Arrow' if scale_bar: layout_item_type = u'Scale Bar' map_item = change_interface(layout_item, ArcGisModules.module_carto.IMapFrame) if map_item: layout_item_type = u'Data Frame' return layout_item_type
def _get_band_stats(arc_raster): arc_raster = change_interface( arc_raster, ArcGisModules.module_data_source_raster.IRaster2) arc_raster_dataset = change_interface( arc_raster.RasterDataset, ArcGisModules.module_gdb.IRasterDataset) arc_raster_band_collection = change_interface( arc_raster_dataset, ArcGisModules.module_data_source_raster.IRasterBandCollection) bandstats = {} for x in range(1, arc_raster_band_collection.Count + 1): raster_band = arc_raster_band_collection.BandByName("Band_" + str(x)) try: band_minimum = raster_band.Statistics.Minimum band_maximum = raster_band.Statistics.Maximum except ValueError: band_minimum = 0 band_maximum = 255 bandstats.update({ x: { "min": unicode(int(band_minimum)), "max": unicode(int(band_maximum)), } }) return bandstats
def adapt_raster_renderer(base, raster_renderer_element): """ here the base renderer is adapted with the specific raster-renderer-content :param base: is the self of the renderer object containing: base.xml_document = xml_document base.map_layer_element = map_layer_element base.arcLayer = arc_layer base.layer = layer base.rendererType = renderer_type :param raster_renderer_element: the raster_renderer_element of the DOM """ arc_raster_layer = change_interface( base.arcLayer, ArcGisModules.module_carto.IRasterLayer) renderer_name = change_interface( arc_raster_layer.Renderer, ArcGisModules.module_carto.IRasterRendererInfo).Name if renderer_name == "Stretched": if arc_raster_layer.BandCount == 3: RasterRenderer._create_singleband_pseudocolor_renderer( base, raster_renderer_element, arc_raster_layer) else: RasterRenderer._create_stretched_renderer( base, raster_renderer_element, arc_raster_layer) if renderer_name == "RGB Composite": RasterRenderer._create_rgb_composite_renderer( base, raster_renderer_element, arc_raster_layer)
def get_point_properties(symbol_properties, i_symbol): """ This function collects all properties of the point symbol :param symbol_properties: This is a dictionary for the properties of a symbol :param i_symbol: this is the used polygon symbol """ symbol_properties['symbol_type'] = "marker" symbol_properties['layer'] = [] multilayer_symbol = change_interface( i_symbol, ArcGisModules.module_display.IMultiLayerMarkerSymbol) if multilayer_symbol: symbol_collection = SymbolPropertiesProvider.get_multilayer_symbol_collection( multilayer_symbol) for symbol in symbol_collection: font_marker = change_interface( symbol, ArcGisModules.module_display.ICharacterMarkerSymbol) picture_marker = change_interface( symbol, ArcGisModules.module_display.IPictureMarkerSymbol) if font_marker: symbol_properties['layer'].append( CharacterMarkerSymbol.create_character_marker_symbol( font_marker)) elif picture_marker: arcpy.AddMessage("Picture Marker are not supported yet.") else: symbol_properties['layer'].append( SimpleMarkerSymbol.create_simple_marker_symbol(symbol)) else: symbol_properties['layer'].append( SimpleMarkerSymbol.create_simple_marker_symbol(i_symbol))
def get_item_properties(item): """ This function returns the properties of an LayoutElement :param item: the item as ArcObject :return: the properties of an item as ArcObject """ element = change_interface(item, ArcGisModules.module_carto.IElement) properties = change_interface( element, ArcGisModules.module_carto.IElementProperties3) return properties
def get_background(formatted_symbol, label_dict): """ This function writes the background specifications in the label_dict if background exists :param formatted_symbol: the text-symbol :param label_dict: the label dictionary including all the label properties """ # implement when possible in qgis # balloon_callout_background = change_interface( # formatted_symbol.Background, # ArcGisModules.module_display.IBalloonCallout # ) line_callout_background = change_interface( formatted_symbol.Background, ArcGisModules.module_display.ILineCallout) marker_text_background = change_interface( formatted_symbol.Background, ArcGisModules.module_display.IMarkerTextBackground) if marker_text_background: label_dict['labelValues']['background']['subsymbol'] = {} SymbolPropertiesProvider.get_point_properties( label_dict['labelValues']['background']['subsymbol'], marker_text_background.Symbol) label_dict['labelValues']['background']['shapeType'] = "5" label_dict['labelValues']['background']['shapeDraw'] = "1" elif line_callout_background: try: formatted_symbol_callout_margin = change_interface( formatted_symbol.Background, ArcGisModules.module_display.ITextMargins) label_dict['labelValues']['background'][ 'shapeFillColor'] = convert_int_to_rgb_string( line_callout_background.Border.Color.RGB) label_dict['labelValues']['background'][ 'shapeBorderColor'] = convert_int_to_rgb_string( line_callout_background.Border.Outline.Color.RGB) label_dict['labelValues']['background'][ 'shapeBorderWidth'] = str( line_callout_background.Border.Outline.Width) label_dict['labelValues']['background']['shapeSizeX'] = str( int(formatted_symbol_callout_margin.LeftMargin) * 2) label_dict['labelValues']['background']['shapeSizeY'] = str( int(formatted_symbol_callout_margin.TopMargin) * 2) label_dict['labelValues']['background']['shapeDraw'] = "1" except ValueError: label_dict['labelValues']['background']['shapeDraw'] = "0" else: pass
def create_label_settings(self, style_gallery, style_gallery_name): """ This creates the labels out of a style-gallery :param style_gallery: the main style gallery :param style_gallery_name: the gallery to read from :return: """ labels_element = self.xml_document.createElement("labelsettings") root_element = self.xml_document.getElementsByTagName("qgis_style")[0] root_element.appendChild(labels_element) style_gallery_items = StyleGalleryItemProvider.get_style_gallery_items( style_gallery, "Labels", style_gallery_name) if len(style_gallery_items) > 0: arcpy.AddMessage("Export {}".format("Labels")) for item in style_gallery_items: try: label_element = self.xml_document.createElement("labelsetting") label_element.setAttribute("name", item.Name) tags = change_interface(item, ArcGisModules.module_display.IStyleGalleryItem2) \ .Tags \ .replace(";", " ,") label_element.setAttribute("tags", tags) labels_element.appendChild(label_element) settings_element = self.xml_document.createElement("settings") settings_element.setAttribute("calloutType", "simple") label_element.appendChild(settings_element) label_style = change_interface( item.Item, ArcGisModules.module_carto.ILabelStyle) formatted_symbol = change_interface( label_style.Symbol, ArcGisModules.module_display.IFormattedTextSymbol) label_dict = copy.deepcopy(labelDict) LabelRenderer.get_text_style(formatted_symbol, label_dict) LabelRenderer.get_background(formatted_symbol, label_dict) LabelRenderer.create_text_style_element( settings_element, self.xml_document, label_dict) LabelRenderer.create_dd_settings(self.xml_document, settings_element) LabelRenderer.create_callout_element( self.xml_document, settings_element, formatted_symbol.Background) except (ValueError, Exception): arcpy.AddMessage("Error while Exporting {}".format(item.name)) continue
def create_geometry_element_content(self, geometry_element_layout, geometry_type): """ This function creates the geometry specific content :param geometry_element_layout: the geometry layout element in the DOM :param geometry_type: the shape type as string """ arcpy_item = LayoutItem.get_arcpy_layout_element( self, self.layout_item_object) GeometryElement.set_size_and_position(self, geometry_element_layout, arcpy_item) geometry_element_layout.setAttribute("frame", "false") geometry_element_layout.setAttribute("background", "false") geometry_element_layout.setAttribute('shapeType', dict_geometry[geometry_type]) geometry_element_layout.setAttribute('type', "65643") GeometryElement.set_uuid_attributes(arcpy_item.name, geometry_element_layout) symbol = change_interface( self.geometry_object, ArcGisModules.module_carto.IFillShapeElement).Symbol symbol_properties = {} SymbolPropertiesProvider.get_polygon_properties( symbol_properties, symbol) SimpleSymbol.create_simple_symbol(self.dom, geometry_element_layout, symbol_properties, 1, '1')
def create_line_properties(line_symbol, symbol_properties): """ This function writes the existing line properties in the symbol_properties dictionary :param line_symbol: the line_symbol to investigate :param symbol_properties: the properties of the line as dictionary """ line_properties = change_interface(line_symbol, ArcGisModules.module_display.ILineProperties) if line_properties: if line_properties.Template: pattern_count = line_properties.Template.PatternElementCount width_counter = 0 custom_dash = '' for pattern_element_index in range(0, pattern_count): pattern_element = line_properties.Template.GetPatternElement(pattern_element_index) if pattern_element_index > 0: custom_dash += ';' custom_dash += '{};{}'.format(pattern_element[0], pattern_element[1]) width_counter += pattern_element[0] + pattern_element[1] symbol_properties['dict_symbols']['customdash'] = custom_dash if not custom_dash == '': symbol_properties['dict_symbols']['use_custom_dash'] = '1' else: symbol_properties['dict_symbols']['use_custom_dash'] = '0' symbol_properties['dict_symbols']['interval'] = str(width_counter * line_properties.Template.Interval) symbol_properties['dict_symbols']['interval_unit'] = 'Point' symbol_properties['dict_symbols']['offset'] = str(line_properties.Offset * -1)
def create_feature_line_symbol(i_symbol): """ This collects all properties of a line symbol and returns a dictionary of them :param i_symbol: the symbol to investigate :return: the symbol_properties as dictionary """ line_dict = copy.deepcopy(SingleSymbol.propDict) symbol_properties = { 'simpleSymbolClass': "SimpleLine", 'dict_symbols': line_dict, } line_symbol_types = LineSymbol.get_line_symbol_types(i_symbol) for line_type, line_symbol in line_symbol_types.items(): LineSymbol.dict_line_creation[line_type](line_symbol, symbol_properties) LineSymbol.create_line_properties(i_symbol, symbol_properties) basic_line_symbol = change_interface(i_symbol, ArcGisModules.module_display.ILineSymbol) if basic_line_symbol.Color.NullColor: symbol_properties['dict_symbols']['line_style'] = 'no' try: layer_color = convert_int_to_rgb_string(basic_line_symbol.Color.RGB) except ValueError: layer_color = '0,0,0,255' arcpy.AddWarning( "\t\tError occured while rendering color. Default color is none." ) symbol_properties['dict_symbols']['line_color'] = layer_color symbol_properties['dict_symbols']['line_width'] = basic_line_symbol.Width return symbol_properties
def get_label_dict(base): """ This function collects all properties of the label and returns them as a dictionary :param base: is the self of the renderer object containing: base.xml_document = xml_document base.map_layer_element = map_layer_element base.arcLayer = arc_layer base.layer = layer base.rendererType = rendererType :return: the label dictionary including all the label properties """ label_dict = copy.deepcopy(labelDict) symbol = None if base.rendererType == "gdb": symbol = LabelRenderer.get_gdb_symbol(base.arcLayer) annotation_class_id = LabelRenderer.get_annotation_class_id( base.arcLayer) label_dict['labelValues']['type'] = 'rule-based' label_dict['labelValues']['classId'] = str(annotation_class_id) label_dict['labelValues']['text-style']['fieldName'] = 'TextString' elif base.rendererType == "feature": symbol = LabelRenderer.specify_feature_content( base.arcLayer, label_dict) formatted_symbol = change_interface( symbol, ArcGisModules.module_display.IFormattedTextSymbol) LabelRenderer.get_text_style(formatted_symbol, label_dict) LabelRenderer.get_background(formatted_symbol, label_dict) return label_dict
def get_layout_items(self): """ This function collects all layout-items and returns them as a list additionally it tells the ZValueProvider the number of items +1 (because of the background element) :return: a list of the layout-items """ if self.arc_doc.ActiveView.IsMapActivated: self.arc_doc.ActiveView = self.arc_doc.PageLayout graphics_container_select = change_interface( self.arc_doc.PageLayout, ArcGisModules.module_carto.IGraphicsContainerSelect) graphics_container_select.SelectAllElements() all_layout_elements = graphics_container_select.SelectedElements count = graphics_container_select.ElementSelectionCount layout_element_object_list = [] for times in range(count): layout_element_object_list.append(all_layout_elements.next()) ZValueProvider.number_of_elements = len(layout_element_object_list) + 1 graphics_container_select.UnselectAllElements() return layout_element_object_list
def create_layout(self): """ This is the Main-Function to create the Layout It collects all layout-items and creates the content for each one. """ units = self.arc_doc.PageLayout.Page.Units UnitProvider.set_origin_unit(units) self.arc_doc.PageLayout.Page.Units = 7 layout_element_dom = Layout.create_base_layout_element(self) layout_item_list = Layout.get_layout_items(self) for item in layout_item_list: try: item_type = LayoutItemPropertiesProvider.get_layout_item_type( item) Layout.create_item_content(self, item_type, item, layout_element_dom) except (KeyError, Exception) as error: item_properties = change_interface( item, ArcGisModules.module_carto.IElementProperties3) logging.error(u"Error while exporting {} - type: {}".format( item_properties.Name, item_properties.Type)) logging.error(error.message) logging.exception(error) continue self.arc_doc.PageLayout.Page.Units = UnitProvider.get_origin_unit()
def create_colorramps(self, style_gallery, style_gallery_name): """ This creates the colorramps out of a style-gallery :param style_gallery: the main style gallery :param style_gallery_name: the gallery to read from """ color_ramps_element = self.xml_document.createElement("colorramps") root_element = self.xml_document.getElementsByTagName("qgis_style")[0] root_element.appendChild(color_ramps_element) style_gallery_items = StyleGalleryItemProvider.get_style_gallery_items( style_gallery, "Color Ramps", style_gallery_name) if len(style_gallery_items) > 0: arcpy.AddMessage("Export {}".format("Color Ramps")) for item in style_gallery_items: try: color_ramp = change_interface( item.Item, ArcGisModules.module_display.IColorRamp) symbol_properties = { 'ramp_name': item.Name, 'tag': style_gallery_name.split(".")[0], 'dict_symbols': {}, } FeatureGradientFillSymbol.create_color_ramp_properties( color_ramp, False, symbol_properties) ColorRampCreator.write_colorramp_in_xml( self, symbol_properties) except (ValueError, Exception): arcpy.AddMessage("Error while Exporting {}".format(item.name)) continue
def create_feature_simple_fill_symbol(i_symbol): """ This collects all properties of a simple fill symbol and returns a dictionary of them :param i_symbol: the symbol to investigate :return: the symbol_properties as dictionary """ fill_dict = copy.deepcopy(SingleSymbol.propDict) symbol_properties = { 'simpleSymbolClass': "SimpleFill", 'dict_symbols': fill_dict } fill_symbol = change_interface( i_symbol, ArcGisModules.module_display.IFillSymbol) try: layer_color = convert_int_to_rgb_string(fill_symbol.Color.RGB) if fill_symbol.Color.NullColor: symbol_properties['dict_symbols']['style'] = "no" else: symbol_properties['dict_symbols']['style'] = "solid" except ValueError: layer_color = '0,0,0,255' symbol_properties['dict_symbols']['style'] = "solid" arcpy.AddWarning( "\t\tError occured while render color. Default Color is black. Default style is solid." ) symbol_properties['dict_symbols']['color'] = layer_color if fill_symbol.Outline: simple_outline = change_interface( fill_symbol.Outline, ArcGisModules.module_display.ISimpleLineSymbol) if simple_outline: if fill_symbol.Outline.Color.NullColor: symbol_properties['dict_symbols']['outline_style'] = "no" else: symbol_properties['dict_symbols']['outline_style'] = \ SingleSymbol.simple_line_style_dict[simple_outline.Style] symbol_properties['dict_symbols'][ 'outline_color'] = convert_int_to_rgb_string( fill_symbol.Outline.Color.RGB) symbol_properties['dict_symbols'][ 'outline_width'] = fill_symbol.Outline.Width return symbol_properties
def get_gdb_symbol(arc_layer): """ This function returns the TextSymbol from the GDB-Layer for labeling :param arc_layer: the layer as arc_object :return: the text-symbol as iSymbol """ # first get annotation-parent-layer, here are the style infos for the fitting ClassId annotation_parent_layer = change_interface( arc_layer, ArcGisModules.module_carto.IAnnotationSublayer).Parent annotation_class_id = LabelRenderer.get_annotation_class_id(arc_layer) # over the Class - Extension you get to the AnnotationClassExtension annotation_class = change_interface(annotation_parent_layer, ArcGisModules.module_gdb.IClass) annotation_class_extension = change_interface( annotation_class.Extension, ArcGisModules.module_carto.IAnnotationClassExtension) # and finally the right formatted symbol symbol = annotation_class_extension.SymbolCollection.Symbol[ annotation_class_id] return symbol
def get_annotation_class_id(arc_layer): """ This function returns the Annotation_Class_Id from the arc_layer :param arc_layer: the layer as arc_object :return: annotation_class_id """ annotation_class_id = change_interface( arc_layer, ArcGisModules.module_carto.IAnnotationSublayer).AnnotationClassID return annotation_class_id
def create_symbols(self, style_gallery, style_gallery_name, class_to_export): """ This creates the symbols out of a style-gallery :param style_gallery: the main style gallery :param style_gallery_name: the gallery to read from :param class_to_export: The name of the class to export """ try: symbols_element = self.xml_document.getElementsByTagName( "symbols")[0] except IndexError: symbols_element = self.xml_document.createElement("symbols") root_element = self.xml_document.getElementsByTagName("qgis_style")[0] root_element.appendChild(symbols_element) style_gallery_items = StyleGalleryItemProvider.get_style_gallery_items( style_gallery, class_to_export, style_gallery_name) if len(style_gallery_items) > 0: arcpy.AddMessage("Export {}".format(class_to_export)) for item in style_gallery_items: try: i_symbol = change_interface( item.Item, ArcGisModules.module_display.ISymbol) symbol_properties = {} SymbolPropertiesProvider.get_symbol_properties_by_symbol_class( symbol_properties, i_symbol, class_to_export) tags = change_interface(item, ArcGisModules.module_display.IStyleGalleryItem2)\ .Tags\ .replace(";", " ,") SimpleSymbol.create_simple_symbol(self.xml_document, symbols_element, symbol_properties, item.Name, "1", tags) except (ValueError, Exception): arcpy.AddMessage("Error while Exporting {}".format(item.name)) continue
def get_style_gallery_items(style_gallery, item_type, style_gallery_name): """ This function reads the items of a given type out of the style-gallery and returns them. :param style_gallery: The Style-Gallery-Object -> IStyleGallery :param item_type: The Typ of the Item (for Example "Marker Symbols") :param style_gallery_name: The name of the style-gallery to export :return: list of StyleGalleryItems """ items_iterator = style_gallery.Items(item_type, style_gallery_name, None) items_iterator.reset() items_list = [] item = change_interface(items_iterator.next(), ArcGisModules.module_display.IStyleGalleryItem) while item is not None: items_list.append(item) item = change_interface( items_iterator.next(), ArcGisModules.module_display.IStyleGalleryItem) return items_list
def get_line_symbol_types(i_symbol): """ This function detects the type of line symbol and returns it :param i_symbol: the symbol to investigate :return: the line type and fitting ArcObject-Symbol as dictionary """ line_symbol_type = {} symbol_hash_line = change_interface(i_symbol, ArcGisModules.module_display.IHashLineSymbol) symbol_marker_line = change_interface(i_symbol, ArcGisModules.module_display.IMarkerLineSymbol) symbol_cartographic_line = change_interface(i_symbol, ArcGisModules.module_display.ICartographicLineSymbol) symbol_simple_line = change_interface(i_symbol, ArcGisModules.module_display.ISimpleLineSymbol) if symbol_hash_line: line_symbol_type["hash"] = symbol_hash_line elif symbol_marker_line: line_symbol_type["marker"] = symbol_marker_line elif symbol_cartographic_line: line_symbol_type["cartographic"] = symbol_cartographic_line elif symbol_simple_line: line_symbol_type["simple"] = symbol_simple_line else: pass return line_symbol_type
def specify_feature_content(arc_layer, label_dict): """ This function writes the feature content in the label_dict and returns the text symbol for labeling :param arc_layer: the layer as arc_object :param label_dict: the label dictionary including all the label properties :return: the text-symbol as iSymbol """ # get the AnnotationProps, that lead to the Labelrenderer and the Symbol feature_layer = change_interface( arc_layer, ArcGisModules.module_carto.IGeoFeatureLayer) annotation_parent_layer = change_interface( feature_layer.AnnotationProperties, ArcGisModules.module_carto.IAnnotateLayerPropertiesCollection2) label_engine = change_interface( annotation_parent_layer.Properties(0), ArcGisModules.module_carto.ILabelEngineLayerProperties2) if feature_layer.DisplayFeatureClass.ShapeType == 3: label_placement = '2' else: label_placement = '0' label_dict['labelValues']['placement']['placement'] = label_placement expression = label_engine.Expression label_dict['labelValues']['type'] = 'simple' label_dict['labelValues']['text-style']['fieldName'] = expression[1:-1] if annotation_parent_layer.Properties(0).AnnotationMaximumScale > 0.0 \ or annotation_parent_layer.Properties(0).AnnotationMinimumScale > 0.0: label_dict['labelValues']['rendering']['scaleVisibility'] = '1' label_dict['labelValues']['rendering']['scaleMax'] = unicode( annotation_parent_layer.Properties(0).AnnotationMinimumScale) label_dict['labelValues']['rendering']['scaleMin'] = unicode( annotation_parent_layer.Properties(0).AnnotationMaximumScale) symbol = label_engine.Symbol return symbol
def _create_stretched_renderer(base, raster_renderer_element, arc_raster_layer): """ This creates the stretched renderer content :param base: is the self of the renderer object containing: base.xml_document = xml_document base.map_layer_element = map_layer_element base.arcLayer = arc_layer base.layer = layer base.rendererType = renderer_type :param raster_renderer_element: the raster_renderer_element of the DOM :param arc_raster_layer: ArcObject of the raster_layer """ raster_renderer_element.setAttribute("type", "singlebandgray") raster_renderer_element.setAttribute("grayBand", "1") renderer = change_interface( arc_raster_layer.Renderer, ArcGisModules.module_carto.IRasterStretchColorRampRenderer) sbg_high = renderer.LabelHigh[7:].split(',')[0] sbg_min = renderer.LabelLow[6:].split(',')[0] sbg_gradient = re.sub(r'[\s+]', '', renderer.ColorScheme.title()) raster_renderer_element.setAttribute("gradient", sbg_gradient) raster_contrast_enhancement_element = base.xml_document.createElement( "contrastEnhancement") raster_renderer_element.appendChild( raster_contrast_enhancement_element) sbg_min_value_element = base.xml_document.createElement("minValue") sbg_min_value_element_content = base.xml_document.createTextNode( sbg_min) sbg_min_value_element.appendChild(sbg_min_value_element_content) raster_contrast_enhancement_element.appendChild(sbg_min_value_element) sbg_max_value_element = base.xml_document.createElement("maxValue") sbg_max_value_element_content = base.xml_document.createTextNode( sbg_high) sbg_max_value_element.appendChild(sbg_max_value_element_content) raster_contrast_enhancement_element.appendChild(sbg_max_value_element) sbg_algorithm_element = base.xml_document.createElement("algorithm") sbg_algorithm_element_content = base.xml_document.createTextNode( "StretchToMinimumMaximum") sbg_algorithm_element.appendChild(sbg_algorithm_element_content) raster_contrast_enhancement_element.appendChild(sbg_algorithm_element)
def create_map_content(self, layout_item_base_element): """ This function creats the frame-item specific content :param layout_item_base_element: the layout element in the DOM """ arcpy_item = LayoutItem.get_arcpy_layout_element( self, self.layout_item_object) LayoutItemFrame.set_size_and_position(self, layout_item_base_element, arcpy_item) frame_properties = change_interface( self.map_object, ArcGisModules.module_carto.IFrameProperties) border = frame_properties.Border background = frame_properties.Background LayoutItemFrame.create_background_and_frame(self, border, background, layout_item_base_element) layout_item_base_element.setAttribute("type", "65639") layout_item_base_element.setAttribute("marginX", "0") layout_item_base_element.setAttribute("marginY", "0") layout_item_base_element.setAttribute("excludeFromExports", "0") layout_item_base_element.setAttribute("drawCanvasItems", "true") layout_item_base_element.setAttribute("rotation", unicode(arcpy_item.rotation)) if self.layout_item_object.Map.Name not in LayoutUuidProvider.uuid_dict: LayoutUuidProvider.create_uuid(self.layout_item_object.Map.Name) uuid = unicode( LayoutUuidProvider.uuid_dict[self.layout_item_object.Map.Name]) layout_item_base_element.setAttribute("uuid", uuid) layout_item_base_element.setAttribute("templateUuid", uuid) layout_item_base_element.setAttribute("followPreset", 'true') layout_item_base_element.setAttribute("followPresetName", arcpy_item.name) extent_element = self.dom.createElement("Extent") extent_element.setAttribute('ymax', "{}".format(arcpy_item.extent.YMax)) extent_element.setAttribute('ymin', "{}".format(arcpy_item.extent.YMin)) extent_element.setAttribute('xmax', "{}".format(arcpy_item.extent.XMax)) extent_element.setAttribute('xmin', "{}".format(arcpy_item.extent.XMin)) layout_item_base_element.appendChild(extent_element)
def create_feature_marker_fill_symbol(i_symbol): """ This collects all properties of a marker fill symbol and returns a dictionary of them :param i_symbol: the symbol to investigate :return: symbol_properties as dictionary """ fill_dict = copy.deepcopy(SingleSymbol.propDict) symbol_properties = { 'simpleSymbolClass': "PointPatternFill", 'dict_symbols': fill_dict, } layer_color = convert_int_to_rgb_string( i_symbol.MarkerSymbol.Color.RGB) symbol_properties['dict_symbols']['color'] = layer_color fill_properties = change_interface( i_symbol, ArcGisModules.module_display.IFillProperties) symbol_properties['dict_symbols']['offset_x'] = str( fill_properties.XOffset) symbol_properties['dict_symbols']['offset_y'] = str( fill_properties.YOffset) symbol_properties['dict_symbols']['offset_x_unit'] = "Pixel" symbol_properties['dict_symbols']['offset_y_unit'] = "Pixel" symbol_properties['dict_symbols']['distance_x'] = str( fill_properties.XSeparation) symbol_properties['dict_symbols']['distance_y'] = str( fill_properties.YSeparation) symbol_properties['dict_symbols']['distance_x_unit'] = "Pixel" symbol_properties['dict_symbols']['distance_y_unit'] = "Pixel" symbol_properties['dict_symbols']['outline_color'] = str( convert_int_to_rgb_string(i_symbol.Outline.Color.RGB)) symbol_properties['dict_symbols']['outline_width'] = str( i_symbol.Outline.Width) SubSymbolProvider.create_sub_symbol(symbol_properties, 'marker') from renderer.feature.symbols.symbolPropertiesProvider import SymbolPropertiesProvider SymbolPropertiesProvider.get_point_properties( symbol_properties['subSymbol'], i_symbol.MarkerSymbol) return symbol_properties
def write_solo_gradient_colors_in_dict(color_ramp, radial_fill, symbol_properties): """This writes the the color-range of the used color-ramp of a multi_gradient_fill_symbol :param color_ramp: The Color Ramp Symbol :param radial_fill: This declares if the gradient has a radial fill - boolean :param symbol_properties: symbol_properties as dictionary """ colors = FeatureGradientFillSymbol.get_colors_from_ramp(color_ramp) first_color = convert_int_to_rgb_string(colors[0].RGB) second_color = convert_int_to_rgb_string(colors[1].RGB) color1 = first_color color2 = second_color if radial_fill: color1 = second_color color2 = first_color symbol_properties['dict_symbols']['color'] = color1 symbol_properties['dict_symbols']['color1'] = color1 symbol_properties['dict_symbols']['color2'] = color2 symbol_properties['dict_symbols']['gradient_color2'] = color2 random_color_ramp = change_interface( color_ramp, ArcGisModules.module_display.IRandomColorRamp) if random_color_ramp: symbol_properties['dict_symbols']['discrete'] = "1" else: symbol_properties['dict_symbols']['color_type'] = "0" color_range = 0.0 if color_ramp.Size == 0 and not random_color_ramp: step_size = 0.5 else: step_size = 1.0 / len(colors) if radial_fill: colors.reverse() for colorNumber, color in enumerate(colors): symbol_properties['dict_symbols']['stops'] += "{};{}".format( color_range, convert_int_to_rgb_string(color.RGB)) if colorNumber != len(colors): symbol_properties['dict_symbols']['stops'] += ":" color_range += step_size
def create_metadata(xml_document, header, arc_app): arc_doc = change_interface(arc_app.Item(0).Document, ArcGisModules.module_carto.IDocumentInfo2) project_metadata = xml_document.createElement('projectMetadata') header.appendChild(project_metadata) project_title = xml_document.createElement('title') project_title_content = xml_document.createTextNode(arc_doc.Name) project_title.appendChild(project_title_content) project_metadata.appendChild(project_title) project_author = xml_document.createElement('author') project_author_content = xml_document.createTextNode(arc_doc.Author) project_author.appendChild(project_author_content) project_metadata.appendChild(project_author) project_author = xml_document.createElement('abstract') project_author_content = xml_document.createTextNode(arc_doc.Subject) project_author.appendChild(project_author_content) project_metadata.appendChild(project_author)