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': "RandomMarkerFill",
            'dict_symbols': fill_dict,
        }
        layer_color = convert_int_to_rgb_string(
            i_symbol.MarkerSymbol.Color.RGB)
        symbol_properties['dict_symbols']['color'] = layer_color
        symbol_properties['dict_symbols']['clip_points'] = '1'
        symbol_properties['dict_symbols']['count_method'] = '1'
        symbol_properties['dict_symbols']['density_area'] = '250'
        symbol_properties['dict_symbols']['density_area_unit'] = 'MM'
        symbol_properties['dict_symbols'][
            'density_area_scale'] = '3x:0,0,0,0,0,0'
        symbol_properties['dict_symbols']['point_count'] = '10'
        symbol_properties['dict_symbols']['seed'] = '48648189'

        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
Esempio n. 2
0
    def create_symbol_marker_line(symbol_marker_line, symbol_properties):
        """ This collects all properties of a marker-line symbol and writes it in the symbol properties

        :param symbol_marker_line: the marker-line symbol
        :param symbol_properties: the belonging properties dictionary
        """
        symbol_properties['simpleSymbolClass'] = "MarkerLine"
        SubSymbolProvider.create_sub_symbol(symbol_properties, 'marker')

        SymbolPropertiesProvider.get_point_properties(
            symbol_properties['subSymbol'], symbol_marker_line.MarkerSymbol)
Esempio n. 3
0
    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
Esempio n. 4
0
    def create_feature_renderer(base):
        """This creates the feature-renderer-element in the DOM

        :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
        """
        renderer = base.xml_document.createElement("renderer-v2")
        renderer.setAttribute("forceraster", "0")
        renderer.setAttribute("enableorderby", "0")
        renderer.setAttribute("symbollevels", "0")
        base.map_layer_element.appendChild(renderer)

        symbols_element = base.xml_document.createElement("symbols")
        renderer.appendChild(symbols_element)

        symbols = []

        arc_feature_layer = change_interface(
            base.arcLayer, ArcGisModules.module_carto.IFeatureLayer)
        arc_geo_feature_layer = change_interface(
            arc_feature_layer, ArcGisModules.module_carto.IGeoFeatureLayer)
        simple_renderer = arc_geo_feature_layer.Renderer
        unique_value_renderer = change_interface(
            simple_renderer, ArcGisModules.module_carto.IUniqueValueRenderer)

        # get a feature, mostly 0 , but can be higher, if using objects from a db -> than takes the id
        feature = None
        try:
            for i in range(0, 1000):
                try:
                    feature = arc_feature_layer.FeatureClass.GetFeature(i)
                    break
                except COMError:
                    i += 1
        except AttributeError:
            arcpy.AddWarning("\t\tFinding a Feature to render failed.")
            print "Something went wrong. Are you using a DB where the IDs start at 1001?"
            pass

        if base.layer.symbologyType == "OTHER" and not unique_value_renderer:
            renderer.setAttribute("type", "singleSymbol")
            symbols.append(simple_renderer.SymbolByFeature(feature))

        elif base.layer.symbologyType == "UNIQUE_VALUES" or unique_value_renderer:
            UniqueValueRenderer.create_unique_values_element(
                base, renderer, symbols)

        elif base.layer.symbologyType == "GRADUATED_COLORS" or "GRADUATED_SYMBOLS":
            GraduatedColorsRenderer.create_graduated_colors_element(
                base, renderer, symbols)

        try:
            arc_feature_layer = change_interface(
                base.arcLayer, ArcGisModules.module_carto.IFeatureLayer)
            layer_effects = change_interface(
                arc_feature_layer, ArcGisModules.module_carto.ILayerEffects)
            alpha = str(1 - layer_effects.Transparency * 0.01)
        except AttributeError:
            alpha = "1"

        # create the symbol element, one for single symbol, more for graduated or unique values
        for count, iSymbol in enumerate(symbols):
            symbol_properties = {}
            if arc_geo_feature_layer.DisplayFeatureClass.ShapeType == 4:
                SymbolPropertiesProvider.get_polygon_properties(
                    symbol_properties, iSymbol)

            elif arc_geo_feature_layer.DisplayFeatureClass.ShapeType == 3:
                SymbolPropertiesProvider.get_line_properties(
                    symbol_properties, iSymbol)

            elif (arc_geo_feature_layer.DisplayFeatureClass.ShapeType == 2) | \
                    (arc_geo_feature_layer.DisplayFeatureClass.ShapeType == 1):
                SymbolPropertiesProvider.get_point_properties(
                    symbol_properties, iSymbol)

            SimpleSymbol.create_simple_symbol(base.xml_document,
                                              symbols_element,
                                              symbol_properties, count, alpha)