def processAlgorithm(self, parameters, context, feedback): # pylint: disable=missing-docstring,too-many-locals
input_file = self.parameterAsString(parameters, self.INPUT, context)
output_file = self.parameterAsFileOutput(parameters, self.OUTPUT, context)
mdbtools_folder = ProcessingConfig.getSetting('MDB_PATH')
style = QgsStyle()
results = {}
for type_index, symbol_type in enumerate(
(Extractor.FILL_SYMBOLS, Extractor.LINE_SYMBOLS, Extractor.MARKER_SYMBOLS)):
feedback.pushInfo('Importing {} from {}'.format(symbol_type, input_file))
raw_symbols = Extractor.extract_styles(input_file, symbol_type, mdbtools_path=mdbtools_folder)
feedback.pushInfo('Found {} symbols of type "{}"\n\n'.format(len(raw_symbols), symbol_type))
if feedback.isCanceled():
break
unreadable = 0
for index, raw_symbol in enumerate(raw_symbols):
feedback.setProgress(index / len(raw_symbols) * 33.3 + 33.3 * type_index)
if feedback.isCanceled():
break
name = raw_symbol[Extractor.NAME]
feedback.pushInfo('{}/{}: {}'.format(index + 1, len(raw_symbols), name))
handle = BytesIO(raw_symbol[Extractor.BLOB])
try:
symbol = read_symbol(file_handle=handle)
except UnreadableSymbolException as e:
feedback.reportError('Error reading symbol {}: {}'.format(name, e))
unreadable += 1
continue
try:
qgis_symbol = Symbol_to_QgsSymbol(symbol)
except NotImplementedException as e:
feedback.reportError(str(e))
unreadable += 1
continue
style.addSymbol(name, qgis_symbol)
if symbol_type == Extractor.FILL_SYMBOLS:
results[self.FILL_SYMBOL_COUNT] = len(raw_symbols)
results[self.UNREADABLE_FILL_SYMBOLS] = unreadable
elif symbol_type == Extractor.LINE_SYMBOLS:
results[self.LINE_SYMBOL_COUNT] = len(raw_symbols)
results[self.UNREADABLE_LINE_SYMBOLS] = unreadable
elif symbol_type == Extractor.MARKER_SYMBOLS:
results[self.MARKER_SYMBOL_COUNT] = len(raw_symbols)
results[self.UNREADABLE_MARKER_SYMBOLS] = unreadable
style.exportXml(output_file)
results[self.OUTPUT] = output_file
return results
def processAlgorithm(
self, # pylint: disable=too-many-locals,too-many-statements,too-many-branches
parameters,
context,
feedback):
input_file = self.parameterAsString(parameters, self.INPUT, context)
output_file = self.parameterAsFileOutput(parameters, self.OUTPUT,
context)
style = QgsStyle()
style.createMemoryDatabase()
warnings = set()
def unsupported_object_callback(msg, level=Context.WARNING):
if msg in warnings:
return
warnings.add(msg)
if level == Context.WARNING:
feedback.reportError('Warning: {}'.format(msg), False)
elif level == Context.CRITICAL:
feedback.reportError(msg, False)
context = Context()
context.unsupported_object_callback = unsupported_object_callback
if Qgis.QGIS_VERSION_INT < 30600:
context.invalid_layer_resolver = GuiUtils.get_valid_mime_uri
# context.style_folder, _ = os.path.split(output_file)
with open(input_file, 'rb') as f:
stream = Stream(f, False, force_layer=True, offset=0)
try:
obj = stream.read_object()
except RequiresLicenseException as e:
raise QgsProcessingException(
'{} - please see https://north-road.com/slyr/ for details'.
format(e)) from e
except UnknownClsidException as e:
feedback.reportError(str(e), fatalError=True)
return {}
except UnreadableSymbolException as e:
feedback.reportError('Unreadable object: {}'.format(e),
fatalError=True)
return {}
except NotImplementedException as e:
feedback.reportError(str(e), fatalError=True)
return {}
except UnicodeDecodeError as e:
feedback.reportError('Unreadable object: {}'.format(e),
fatalError=True)
return {}
if not LayerConverter.is_layer(obj) and not isinstance(
obj, GroupLayer):
feedback.reportError('Objects of type {} are not supported'.format(
obj.__class__.__name__),
fatalError=False)
return {}
symbol_names = set()
def make_name_unique(original_name):
"""
Ensures that the symbol name is unique (in a case-insensitive way)
"""
counter = 0
candidate = original_name
while candidate.lower() in symbol_names:
# make name unique
if counter == 0:
candidate += '_1'
else:
candidate = candidate[:candidate.rfind('_') +
1] + str(counter)
counter += 1
symbol_names.add(candidate.lower())
return candidate
layers = LayerConverter.unique_layer_name_map(obj)
for name, layer in layers.items():
feedback.pushInfo('Extracting symbols from {}'.format(name))
symbols = VectorRendererConverter.extract_symbols_from_renderer(
layer,
context,
default_name=name,
base_name=name if len(layers) > 1 else '')
for k, v in symbols.items():
unique_name = make_name_unique(k)
if k != unique_name:
feedback.pushInfo(
'Corrected to unique name of {}'.format(unique_name))
if isinstance(v, QgsSymbol):
style.addSymbol(unique_name, v, True)
elif isinstance(v, QgsColorRamp):
style.addColorRamp(unique_name, v, True)
elif isinstance(v, QgsTextFormat):
if Qgis.QGIS_VERSION_INT >= 30900:
style.addTextFormat(unique_name, v, True)
style.exportXml(output_file)
return {self.OUTPUT: output_file}
if not args.destination:
args.destination = '/home/nyall/Styles/GEO_Surface___Solid_Shades.xml'
styles = [(args.file, Extractor.FILL_SYMBOLS)]
style = QgsStyle()
for (fill_style_db, symbol_type) in styles:
print('{}:{}'.format(fill_style_db, symbol_type))
raw_symbols = Extractor.extract_styles(fill_style_db, symbol_type)
print('Found {} symbols of type "{}"\n\n'.format(len(raw_symbols),
symbol_type))
for index, raw_symbol in enumerate(raw_symbols):
name = raw_symbol[Extractor.NAME]
# print('{}/{}: {}'.format(index + 1, len(raw_symbols),name))
handle = BytesIO(raw_symbol[Extractor.BLOB])
try:
symbol = read_symbol(file_handle=handle)
except UnreadableSymbolException:
print('Error reading symbol {}'.format(name))
continue
qgis_symbol = FillSymbol_to_QgsFillSymbol(symbol)
style.addSymbol(name, qgis_symbol)
style.exportXml(args.destination)
def processAlgorithm(self, parameters, context, feedback): # pylint: disable=missing-docstring,too-many-locals,too-many-statements
input_file = self.parameterAsString(parameters, self.INPUT, context)
output_file = self.parameterAsFileOutput(parameters, self.OUTPUT,
context)
mdbtools_folder = ProcessingConfig.getSetting('MDB_PATH')
style = QgsStyle()
results = {}
symbol_names = set()
def make_name_unique(name):
"""
Ensures that the symbol name is unique (in a case insensitive way)
"""
counter = 0
candidate = name
while candidate.lower() in symbol_names:
# make name unique
if counter == 0:
candidate += '_1'
else:
candidate = candidate[:candidate.rfind('_') +
1] + str(counter)
counter += 1
symbol_names.add(candidate.lower())
return candidate
for type_index, symbol_type in enumerate(
(Extractor.FILL_SYMBOLS, Extractor.LINE_SYMBOLS,
Extractor.MARKER_SYMBOLS)):
feedback.pushInfo('Importing {} from {}'.format(
symbol_type, input_file))
raw_symbols = Extractor.extract_styles(
input_file, symbol_type, mdbtools_path=mdbtools_folder)
feedback.pushInfo('Found {} symbols of type "{}"\n\n'.format(
len(raw_symbols), symbol_type))
if feedback.isCanceled():
break
unreadable = 0
for index, raw_symbol in enumerate(raw_symbols):
feedback.setProgress(index / len(raw_symbols) * 33.3 +
33.3 * type_index)
if feedback.isCanceled():
break
name = raw_symbol[Extractor.NAME]
feedback.pushInfo('{}/{}: {}'.format(index + 1,
len(raw_symbols), name))
unique_name = make_name_unique(name)
if name != unique_name:
feedback.pushInfo(
'Corrected to unique name of {}'.format(unique_name))
handle = BytesIO(raw_symbol[Extractor.BLOB])
stream = Stream(handle)
try:
symbol = stream.read_object()
except UnreadableSymbolException as e:
feedback.reportError('Error reading symbol {}: {}'.format(
name, e))
unreadable += 1
continue
except NotImplementedException as e:
feedback.reportError(
'Parsing {} is not supported: {}'.format(name, e))
unreadable += 1
continue
except UnsupportedVersionException as e:
feedback.reportError('Cannot read {} version: {}'.format(
name, e))
unreadable += 1
continue
try:
qgis_symbol = Symbol_to_QgsSymbol(symbol)
except NotImplementedException as e:
feedback.reportError(str(e))
unreadable += 1
continue
style.addSymbol(unique_name, qgis_symbol)
if symbol_type == Extractor.FILL_SYMBOLS:
results[self.FILL_SYMBOL_COUNT] = len(raw_symbols)
results[self.UNREADABLE_FILL_SYMBOLS] = unreadable
elif symbol_type == Extractor.LINE_SYMBOLS:
results[self.LINE_SYMBOL_COUNT] = len(raw_symbols)
results[self.UNREADABLE_LINE_SYMBOLS] = unreadable
elif symbol_type == Extractor.MARKER_SYMBOLS:
results[self.MARKER_SYMBOL_COUNT] = len(raw_symbols)
results[self.UNREADABLE_MARKER_SYMBOLS] = unreadable
style.exportXml(output_file)
results[self.OUTPUT] = output_file
return results
def processAlgorithm(
self, # pylint:disable=too-many-locals,too-many-statements,too-many-branches
parameters,
context,
feedback):
input_file = self.parameterAsString(parameters, self.INPUT, context)
output_file = self.parameterAsFileOutput(parameters, self.OUTPUT,
context)
fields = QgsFields()
fields.append(QgsField('name', QVariant.String, '', 60))
fields.append(QgsField('warning', QVariant.String, '', 250))
sink, dest = self.parameterAsSink(parameters, self.REPORT, context,
fields)
style = QgsStyle()
style.createMemoryDatabase()
results = {}
symbol_names = set()
def make_name_unique(original_name):
"""
Ensures that the symbol name is unique (in a case-insensitive way)
"""
counter = 0
candidate = original_name
while candidate.lower() in symbol_names:
# make name unique
if counter == 0:
candidate += '_1'
else:
candidate = candidate[:candidate.rfind('_') +
1] + str(counter)
counter += 1
symbol_names.add(candidate.lower())
return candidate
symbols_to_extract = [
Extractor.FILL_SYMBOLS, Extractor.LINE_SYMBOLS,
Extractor.MARKER_SYMBOLS, Extractor.COLOR_RAMPS,
Extractor.LINE_PATCHES, Extractor.AREA_PATCHES
]
if Qgis.QGIS_VERSION_INT >= 30900:
symbols_to_extract.extend(
(Extractor.TEXT_SYMBOLS, Extractor.LABELS,
Extractor.MAPLEX_LABELS))
type_percent = 100.0 / len(symbols_to_extract)
results[self.LABEL_SETTINGS_COUNT] = 0
results[self.UNREADABLE_LABEL_SETTINGS] = 0
for type_index, symbol_type in enumerate(symbols_to_extract):
feedback.pushInfo('Importing {} from {}'.format(
symbol_type, input_file))
try:
raw_symbols = Extractor.extract_styles(input_file, symbol_type)
except MissingBinaryException:
raise QgsProcessingException( # pylint: disable=raise-missing-from
'The MDB tools "mdb-export" utility is required to convert .style databases. Please setup a path to the MDB tools utility in the SLYR options panel.'
)
feedback.pushInfo('Found {} symbols of type "{}"\n\n'.format(
len(raw_symbols), symbol_type))
if feedback.isCanceled():
break
unreadable = 0
for index, raw_symbol in enumerate(raw_symbols):
feedback.setProgress(index / len(raw_symbols) * type_percent +
type_percent * type_index)
if feedback.isCanceled():
break
name = raw_symbol[Extractor.NAME]
tags = raw_symbol[Extractor.TAGS].split(';')
feedback.pushInfo('{}/{}: {}'.format(index + 1,
len(raw_symbols), name))
unique_name = make_name_unique(name)
if name != unique_name:
feedback.pushInfo(
'Corrected to unique name of {}'.format(unique_name))
handle = BytesIO(raw_symbol[Extractor.BLOB])
stream = Stream(handle)
f = QgsFeature()
try:
symbol = stream.read_object()
except UnreadableSymbolException as e:
feedback.reportError(
'Error reading symbol {}: {}'.format(name, e), False)
unreadable += 1
if sink:
f.setAttributes(
[name, 'Error reading symbol: {}'.format(e)])
sink.addFeature(f)
continue
except NotImplementedException as e:
feedback.reportError(
'Parsing {} is not supported: {}'.format(name, e),
False)
unreadable += 1
if sink:
f.setAttributes(
[name, 'Parsing not supported: {}'.format(e)])
sink.addFeature(f)
continue
except UnsupportedVersionException as e:
feedback.reportError(
'Cannot read {} version: {}'.format(name, e), False)
unreadable += 1
if sink:
f.setAttributes(
[name, 'Version not supported: {}'.format(e)])
sink.addFeature(f)
continue
except UnknownClsidException as e:
feedback.reportError(str(e), False)
unreadable += 1
if sink:
f.setAttributes([name, 'Unknown object: {}'.format(e)])
sink.addFeature(f)
continue
except UnreadablePictureException as e:
feedback.reportError(str(e), False)
unreadable += 1
if sink:
f.setAttributes(
[name, 'Unreadable picture: {}'.format(e)])
sink.addFeature(f)
continue
def unsupported_object_callback(msg, level=Context.WARNING):
if level == Context.WARNING:
feedback.reportError('Warning: {}'.format(msg), False)
elif level == Context.CRITICAL:
feedback.reportError(msg, False)
if sink:
feat = QgsFeature()
feat.setAttributes([name, msg]) # pylint: disable=cell-var-from-loop
sink.addFeature(feat)
context = Context()
context.symbol_name = unique_name
context.style_folder, _ = os.path.split(output_file)
context.unsupported_object_callback = unsupported_object_callback
if symbol_type in (Extractor.AREA_PATCHES,
Extractor.LINE_PATCHES):
feedback.reportError(
'{}: Legend patch conversion requires the licensed version of SLYR'
.format(name), False)
unreadable += 1
if sink:
f.setAttributes(
[name, 'Unreadable legend patch: {}'.format(name)])
sink.addFeature(f)
continue
try:
qgis_symbol = SymbolConverter.Symbol_to_QgsSymbol(
symbol, context)
except NotImplementedException as e:
feedback.reportError(str(e), False)
unreadable += 1
if sink:
f.setAttributes([name, str(e)])
sink.addFeature(f)
continue
except UnreadablePictureException as e:
feedback.reportError(str(e), False)
unreadable += 1
if sink:
f.setAttributes(
[name, 'Unreadable picture: {}'.format(e)])
sink.addFeature(f)
continue
if isinstance(qgis_symbol, QgsSymbol):
style.addSymbol(unique_name, qgis_symbol, True)
elif isinstance(qgis_symbol, QgsColorRamp):
style.addColorRamp(unique_name, qgis_symbol, True)
elif isinstance(qgis_symbol, QgsTextFormat):
if Qgis.QGIS_VERSION_INT >= 30900:
style.addTextFormat(unique_name, qgis_symbol, True)
elif isinstance(qgis_symbol, QgsPalLayerSettings):
if Qgis.QGIS_VERSION_INT >= 30900:
style.addLabelSettings(unique_name, qgis_symbol, True)
elif Qgis.QGIS_VERSION_INT >= 31300:
if isinstance(qgis_symbol, QgsLegendPatchShape):
style.addLegendPatchShape(unique_name, qgis_symbol,
True)
if tags:
if isinstance(qgis_symbol, QgsSymbol):
assert style.tagSymbol(QgsStyle.SymbolEntity,
unique_name, tags)
elif isinstance(qgis_symbol, QgsColorRamp):
assert style.tagSymbol(QgsStyle.ColorrampEntity,
unique_name, tags)
elif isinstance(qgis_symbol, QgsTextFormat) and hasattr(
QgsStyle, 'TextFormatEntity'):
assert style.tagSymbol(QgsStyle.TextFormatEntity,
unique_name, tags)
elif isinstance(qgis_symbol,
QgsPalLayerSettings) and hasattr(
QgsStyle, 'LabelSettingsEntity'):
assert style.tagSymbol(QgsStyle.LabelSettingsEntity,
unique_name, tags)
elif Qgis.QGIS_VERSION_INT >= 31300:
if isinstance(qgis_symbol, QgsLegendPatchShape):
assert style.tagSymbol(
QgsStyle.LegendPatchShapeEntity, unique_name,
tags)
if symbol_type == Extractor.FILL_SYMBOLS:
results[self.FILL_SYMBOL_COUNT] = len(raw_symbols)
results[self.UNREADABLE_FILL_SYMBOLS] = unreadable
elif symbol_type == Extractor.LINE_SYMBOLS:
results[self.LINE_SYMBOL_COUNT] = len(raw_symbols)
results[self.UNREADABLE_LINE_SYMBOLS] = unreadable
elif symbol_type == Extractor.MARKER_SYMBOLS:
results[self.MARKER_SYMBOL_COUNT] = len(raw_symbols)
results[self.UNREADABLE_MARKER_SYMBOLS] = unreadable
elif symbol_type == Extractor.COLOR_RAMPS:
results[self.COLOR_RAMP_COUNT] = len(raw_symbols)
results[self.UNREADABLE_COLOR_RAMPS] = unreadable
elif symbol_type == Extractor.TEXT_SYMBOLS:
results[self.TEXT_FORMAT_COUNT] = len(raw_symbols)
results[self.UNREADABLE_TEXT_FORMATS] = unreadable
elif symbol_type in (Extractor.MAPLEX_LABELS, Extractor.LABELS):
results[self.LABEL_SETTINGS_COUNT] += len(raw_symbols)
results[self.UNREADABLE_LABEL_SETTINGS] += unreadable
elif symbol_type == Extractor.LINE_PATCHES:
results[self.LINE_PATCH_COUNT] = len(raw_symbols)
results[self.UNREADABLE_LINE_PATCHES] = unreadable
elif symbol_type == Extractor.AREA_PATCHES:
results[self.AREA_PATCH_COUNT] = len(raw_symbols)
results[self.UNREADABLE_AREA_PATCHES] = unreadable
style.exportXml(output_file)
results[self.OUTPUT] = output_file
results[self.REPORT] = dest
return results
def processAlgorithm(self, # pylint:disable=missing-docstring,too-many-locals,too-many-statements,too-many-branches
parameters,
context,
feedback):
input_file = self.parameterAsString(parameters, self.INPUT, context)
output_file = self.parameterAsFileOutput(parameters, self.OUTPUT, context)
embed_pictures = self.parameterAsBool(parameters, self.EMBED_PICTURES, context)
convert_fonts = self.parameterAsBool(parameters, self.CONVERT_FONTS, context)
parameterize = self.parameterAsBool(parameters, self.PARAMETERIZE, context)
units = self.parameterAsEnum(parameters, self.UNITS, context)
force_svg = self.parameterAsBool(parameters, self.FORCE_SVG, context)
relative_paths = self.parameterAsBool(parameters, self.RELATIVE_PATHS, context)
picture_folder = self.parameterAsString(parameters, self.PICTURE_FOLDER, context)
if not picture_folder:
picture_folder, _ = os.path.split(output_file)
mdbtools_folder = ProcessingConfig.getSetting('MDB_PATH')
fields = QgsFields()
fields.append(QgsField('name', QVariant.String, '', 60))
fields.append(QgsField('warning', QVariant.String, '', 250))
sink, dest = self.parameterAsSink(parameters, self.REPORT, context, fields)
style = QgsStyle()
style.createMemoryDatabase()
results = {}
symbol_names = set()
def make_name_unique(name):
"""
Ensures that the symbol name is unique (in a case insensitive way)
"""
counter = 0
candidate = name
while candidate.lower() in symbol_names:
# make name unique
if counter == 0:
candidate += '_1'
else:
candidate = candidate[:candidate.rfind('_') + 1] + str(counter)
counter += 1
symbol_names.add(candidate.lower())
return candidate
for type_index, symbol_type in enumerate(
(Extractor.FILL_SYMBOLS, Extractor.LINE_SYMBOLS, Extractor.MARKER_SYMBOLS, Extractor.COLOR_RAMPS)):
feedback.pushInfo('Importing {} from {}'.format(symbol_type, input_file))
raw_symbols = Extractor.extract_styles(input_file, symbol_type, mdbtools_path=mdbtools_folder)
feedback.pushInfo('Found {} symbols of type "{}"\n\n'.format(len(raw_symbols), symbol_type))
if feedback.isCanceled():
break
unreadable = 0
for index, raw_symbol in enumerate(raw_symbols):
feedback.setProgress(index / len(raw_symbols) * 33.3 + 33.3 * type_index)
if feedback.isCanceled():
break
name = raw_symbol[Extractor.NAME]
tags = raw_symbol[Extractor.TAGS].split(';')
feedback.pushInfo('{}/{}: {}'.format(index + 1, len(raw_symbols), name))
unique_name = make_name_unique(name)
if name != unique_name:
feedback.pushInfo('Corrected to unique name of {}'.format(unique_name))
handle = BytesIO(raw_symbol[Extractor.BLOB])
stream = Stream(handle)
f = QgsFeature()
try:
symbol = stream.read_object()
except UnreadableSymbolException as e:
feedback.reportError('Error reading symbol {}: {}'.format(name, e))
unreadable += 1
if sink:
f.setAttributes([name, 'Error reading symbol: {}'.format(e)])
sink.addFeature(f)
continue
except NotImplementedException as e:
feedback.reportError('Parsing {} is not supported: {}'.format(name, e))
unreadable += 1
if sink:
f.setAttributes([name, 'Parsing not supported: {}'.format(e)])
sink.addFeature(f)
continue
except UnsupportedVersionException as e:
feedback.reportError('Cannot read {} version: {}'.format(name, e))
unreadable += 1
if sink:
f.setAttributes([name, 'Version not supported: {}'.format(e)])
sink.addFeature(f)
continue
except UnknownGuidException as e:
feedback.reportError(str(e))
unreadable += 1
if sink:
f.setAttributes([name, 'Unknown object: {}'.format(e)])
sink.addFeature(f)
continue
except UnreadablePictureException as e:
feedback.reportError(str(e))
unreadable += 1
if sink:
f.setAttributes([name, 'Unreadable picture: {}'.format(e)])
sink.addFeature(f)
continue
self.check_for_unsupported_property(name, symbol, feedback, sink)
context = Context()
context.symbol_name = unique_name
context.picture_folder = picture_folder
context.embed_pictures = embed_pictures
context.convert_fonts = convert_fonts
context.parameterise_svg = parameterize
context.force_svg_instead_of_raster = force_svg
context.relative_paths = relative_paths
context.style_folder, _ = os.path.split(output_file)
context.units = QgsUnitTypes.RenderPoints if units == 0 else QgsUnitTypes.RenderMillimeters
try:
qgis_symbol = Symbol_to_QgsSymbol(symbol, context)
except NotImplementedException as e:
feedback.reportError(str(e))
unreadable += 1
if sink:
f.setAttributes([name, str(e)])
sink.addFeature(f)
continue
if isinstance(qgis_symbol, QgsSymbol):
self.check_for_missing_fonts(qgis_symbol, feedback)
style.addSymbol(unique_name, qgis_symbol, True)
elif isinstance(qgis_symbol, QgsColorRamp):
style.addColorRamp(unique_name, qgis_symbol, True)
if tags:
if isinstance(qgis_symbol, QgsSymbol):
assert style.tagSymbol(QgsStyle.SymbolEntity, unique_name, tags)
elif isinstance(qgis_symbol, QgsColorRamp):
assert style.tagSymbol(QgsStyle.ColorrampEntity, unique_name, tags)
if symbol_type == Extractor.FILL_SYMBOLS:
results[self.FILL_SYMBOL_COUNT] = len(raw_symbols)
results[self.UNREADABLE_FILL_SYMBOLS] = unreadable
elif symbol_type == Extractor.LINE_SYMBOLS:
results[self.LINE_SYMBOL_COUNT] = len(raw_symbols)
results[self.UNREADABLE_LINE_SYMBOLS] = unreadable
elif symbol_type == Extractor.MARKER_SYMBOLS:
results[self.MARKER_SYMBOL_COUNT] = len(raw_symbols)
results[self.UNREADABLE_MARKER_SYMBOLS] = unreadable
elif symbol_type == Extractor.COLOR_RAMPS:
results[self.COLOR_RAMP_COUNT] = len(raw_symbols)
results[self.UNREADABLE_COLOR_RAMPS] = unreadable
style.exportXml(output_file)
results[self.OUTPUT] = output_file
results[self.REPORT] = dest
return results
def run(self):
"""
Start the library generation
"""
patched_xml = ['S_01_081_0017', 'S_01_081_0018',
'S_14_145_0015', 'S_05_019_0001',
'L_19_006_0008', 'L_25_116_0001',
'S_11_042_0013', 'L_21_105_0002',
'L_21_107_0010', 'L_22_092_0003',
'L_22_092_0008', 'L_22_092_0009',
'L_22_092_0010', 'L_22_092_0011',
'L_22_092_0012', 'P_31_159_0002',
'S_01_081_0010', 'S_01_089_0016',
'S_05_017_0008', 'S_10_041_0004',
'S_13_046_0012', 'S_13_046_0018',
'S_14_048_0008', 'S_18_071_0001',
'P_28_157_0001', 'P_32_160_0001',
'P_33_161_0001']
# Symbols for which it exists a manually modified svg
patched_svg = ['P_26_120_0015', 'P_33_172_0001',
'P_26_122_0007', 'P_26_124_0004_1',
'L_20_099_0006', 'L_20_099_0007',
'L_20_099_0009', 'L_20_099_0011',
'P_28_157_0001', 'P_32_160_0001',
'P_33_161_0001']
blobs = []
style = QgsStyle()
context = Context()
context.units = QgsUnitTypes.RenderMillimeters
context.relative_paths = True
context.picture_folder = os.path.join(
self.output_directory, 'svg')
context.convert_fonts = True
context.force_svg_instead_of_raster = True
context.parameterise_svg = False
context.embed_pictures = False
a = QApplication([])
for fn in os.listdir(self.bin_directory):
file = os.path.join(self.bin_directory, fn)
if os.path.isfile(file):
blobs.append(file)
symbol_name = os.path.splitext(fn)[0]
with open(file, 'rb') as f:
context.symbol_name = symbol_name
symbol = read_symbol(f, debug=False)
qgis_symbol = Symbol_to_QgsSymbol(symbol, context)
if symbol_name in patched_xml:
xml_file = os.path.join(
self.patched_xml_directory,
symbol_name + '.xml')
style.importXml(xml_file)
print("Patch symbol {} with {}".format(
symbol_name, xml_file))
continue
style.addSymbol(symbol_name, qgis_symbol)
style.exportXml(
os.path.join(self.output_directory, 'libreria.xml'))
for svg in patched_svg:
svg_src = os.path.join(self.patched_svg_directory, svg + '.svg')
svg_dest = os.path.join(
self.output_directory, 'svg', svg + '.svg')
copyfile(svg_src, svg_dest)
print("Patch svg {} with {}".format(svg_dest, svg_src))
