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)
