001 //$$HeadURL: svn+ssh://jwilden@svn.wald.intevation.org/deegree/base/branches/2.5_testing/src/org/deegree/tools/shape/AVL2SLD.java $$
002 /*----------------------------------------------------------------------------
003 This file is part of deegree, http://deegree.org/
004 Copyright (C) 2001-2009 by:
005 Department of Geography, University of Bonn
006 and
007 lat/lon GmbH
008
009 This library is free software; you can redistribute it and/or modify it under
010 the terms of the GNU Lesser General Public License as published by the Free
011 Software Foundation; either version 2.1 of the License, or (at your option)
012 any later version.
013 This library is distributed in the hope that it will be useful, but WITHOUT
014 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
015 FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
016 details.
017 You should have received a copy of the GNU Lesser General Public License
018 along with this library; if not, write to the Free Software Foundation, Inc.,
019 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
020
021 Contact information:
022
023 lat/lon GmbH
024 Aennchenstr. 19, 53177 Bonn
025 Germany
026 http://lat-lon.de/
027
028 Department of Geography, University of Bonn
029 Prof. Dr. Klaus Greve
030 Postfach 1147, 53001 Bonn
031 Germany
032 http://www.geographie.uni-bonn.de/deegree/
033
034 e-mail: info@deegree.org
035 ----------------------------------------------------------------------------*/
036
037 package org.deegree.tools.shape;
038
039 import java.awt.Color;
040 import java.awt.image.BufferedImage;
041 import java.io.File;
042 import java.io.FileOutputStream;
043 import java.io.FileReader;
044 import java.io.FileWriter;
045 import java.io.FilenameFilter;
046 import java.io.IOException;
047 import java.io.Reader;
048 import java.util.ArrayList;
049 import java.util.HashMap;
050 import java.util.List;
051 import java.util.Map;
052 import java.util.regex.Matcher;
053 import java.util.regex.Pattern;
054
055 import org.deegree.datatypes.QualifiedName;
056 import org.deegree.framework.util.ImageUtils;
057 import org.deegree.framework.util.StringTools;
058 import org.deegree.framework.xml.Marshallable;
059 import org.deegree.graphics.sld.AbstractLayer;
060 import org.deegree.graphics.sld.AbstractStyle;
061 import org.deegree.graphics.sld.ExternalGraphic;
062 import org.deegree.graphics.sld.FeatureTypeStyle;
063 import org.deegree.graphics.sld.Fill;
064 import org.deegree.graphics.sld.Font;
065 import org.deegree.graphics.sld.Graphic;
066 import org.deegree.graphics.sld.GraphicFill;
067 import org.deegree.graphics.sld.LabelPlacement;
068 import org.deegree.graphics.sld.LineSymbolizer;
069 import org.deegree.graphics.sld.Mark;
070 import org.deegree.graphics.sld.NamedLayer;
071 import org.deegree.graphics.sld.PointPlacement;
072 import org.deegree.graphics.sld.PointSymbolizer;
073 import org.deegree.graphics.sld.PolygonSymbolizer;
074 import org.deegree.graphics.sld.Rule;
075 import org.deegree.graphics.sld.Stroke;
076 import org.deegree.graphics.sld.StyleFactory;
077 import org.deegree.graphics.sld.StyledLayerDescriptor;
078 import org.deegree.graphics.sld.Symbolizer;
079 import org.deegree.graphics.sld.TextSymbolizer;
080 import org.deegree.io.shpapi.MainFile;
081 import org.deegree.io.shpapi.ShapeConst;
082 import org.deegree.model.filterencoding.ComplexFilter;
083 import org.deegree.model.filterencoding.Filter;
084 import org.deegree.model.filterencoding.FilterConstructionException;
085 import org.deegree.model.filterencoding.Literal;
086 import org.deegree.model.filterencoding.LogicalOperation;
087 import org.deegree.model.filterencoding.Operation;
088 import org.deegree.model.filterencoding.OperationDefines;
089 import org.deegree.model.filterencoding.PropertyIsCOMPOperation;
090 import org.deegree.model.filterencoding.PropertyName;
091
092 /**
093 * <p>
094 * This class converts ESRI *.avl files to OGC SLD documents. The current version of this tool isn't
095 * able to convert each and every construction that is possible with an *.avl file. But most of the
096 * common expressions will be mapped.
097 * </p>
098 * <p>
099 * Because SLD (version 1.0.0) does not know inline bitmap or fill pattern definition directly
100 * (maybe it is possible using some SVG tags) all polygon fill patterns must be converted to images
101 * that are written to the file system and referenced as external graphic by the created SLD style.
102 * The similar is true for symbol definitions. SLD just 'knowns' a few predefined symbols that are
103 * not able to capture all symbols known by ArcView. In this context deegree also will extend the
104 * well known symbol by using ASCII codes to references symbols defined in an available font. This
105 * will enable deegree to transform the ArcView option defining a symbol by using an ACSII character
106 * directly. At least even if the synthax for this is SLD compliant most SLD implementation probably
107 * won't be able to evaluate this.
108 * </p>
109 *
110 * @author <a href="mailto:poth@lat-lon.de">Andreas Poth </a>
111 * @author last edited by: $Author: mschneider $
112 *
113 * @version $Revision: 18195 $, $Date: 2009-06-18 17:55:39 +0200 (Do, 18 Jun 2009) $
114 */
115 public class AVL2SLD {
116
117 private String fileRootName = null;
118
119 private String targetDir = null;
120
121 private Map<String, Map<String, Object>> blocks = new HashMap<String, Map<String, Object>>();
122
123 private static AVLPointSymbolCodeList cl = null;
124
125 /**
126 * @param fileRootName
127 * @param targetDir
128 */
129 public AVL2SLD( String fileRootName, String targetDir ) {
130 this.fileRootName = fileRootName;
131 this.targetDir = targetDir;
132 if ( !this.targetDir.endsWith( "/" ) ) {
133 this.targetDir = this.targetDir + "/";
134 }
135 }
136
137 /**
138 * reads the avl file assigned to a class instance
139 *
140 * @throws IOException
141 */
142 public void read()
143 throws IOException {
144 Reader reader = new FileReader( fileRootName + ".avl" );
145 StringBuffer sb = new StringBuffer( 50000 );
146 int c = 0;
147 while ( ( c = reader.read() ) > -1 ) {
148 if ( c == 9 )
149 c = ' ';
150 // if ( c != 10 && c != 13) {
151 sb.append( (char) c );
152 // }
153 }
154 reader.close();
155
156 // create a entry in 'blocks' for each '(' ... ')'
157 // enclosed section
158 String[] s1 = splitavl( sb.toString() );
159
160 for ( int i = 1; i < s1.length; i++ ) {
161 // write each KVP of section to a map and store it
162 // in the blocks map.
163 // the Class, Pattern and he Child key will be treated
164 // as array because it isn't unique
165 int pos = s1[i].indexOf( ' ' );
166 if ( pos < 0 )
167 continue;
168 String section = s1[i].substring( 0, pos ).trim();
169 String[] s2 = StringTools.toArray( s1[i].substring( pos, s1[i].length() ), ":\n", false );
170 Map<String, Object> block = new HashMap<String, Object>();
171 for ( int j = 0; j < s2.length; j = j + 2 ) {
172 if ( s2[j].trim().equals( "Class" ) ) {
173 List<String> list = (List<String>) block.get( "Class" );
174 if ( list == null ) {
175 list = new ArrayList<String>();
176 }
177 list.add( s2[j + 1] );
178 block.put( s2[j], list );
179 } else if ( s2[j].trim().equals( "Child" ) ) {
180 List<String> list = (List<String>) block.get( "Child" );
181 if ( list == null ) {
182 list = new ArrayList<String>();
183 }
184 list.add( s2[j + 1] );
185 block.put( s2[j], list );
186 } else if ( s2[j].trim().equals( "Pattern" ) ) {
187 List<String> list = (List<String>) block.get( "Pattern" );
188 if ( list == null ) {
189 list = new ArrayList<String>();
190 }
191 list.add( s2[j + 1] );
192 block.put( s2[j], list );
193 } else if ( s2[j].trim().equals( "Bits" ) ) {
194 List<String> list = (List<String>) block.get( "Bits" );
195 if ( list == null ) {
196 list = new ArrayList<String>();
197 }
198 list.add( s2[j + 1] );
199 block.put( s2[j], list );
200 } else {
201 block.put( s2[j], s2[j + 1].trim() );
202 }
203 }
204 blocks.put( section, block );
205 }
206
207 }
208
209 /**
210 * returns a <tt>Style</tt>. For each class/child contained in a avl file one <tt>Rule</tt>
211 * will be created
212 *
213 * @return a <tt>Style</tt>. For each class/child contained in a avl file one <tt>Rule</tt>
214 * will be created
215 * @throws IOException
216 * @throws Exception
217 */
218 public AbstractStyle getStyle()
219 throws IOException, Exception {
220 Map odb = blocks.get( "ODB.1" );
221 String roots = (String) odb.get( "Roots" );
222 Map legend = blocks.get( "Legend." + roots );
223 String filterCol = null;
224 if ( legend.get( "FieldNames" ) != null ) {
225 Map block = blocks.get( "AVStr." + legend.get( "FieldNames" ) );
226 filterCol = (String) block.get( "S" );
227 filterCol = StringTools.validateString( filterCol, "\"" ).toUpperCase();
228 }
229
230 int geoType = getGeometryType();
231
232 AbstractStyle style = null;
233 switch ( geoType ) {
234 case ShapeConst.SHAPE_TYPE_POINT:
235 style = createPointStyle( legend, filterCol );
236 break;
237 case ShapeConst.SHAPE_TYPE_POLYLINE:
238 style = createLinesStyle( legend, filterCol );
239 break;
240 case ShapeConst.SHAPE_TYPE_POLYGON:
241 style = createPolygonStyle( legend, filterCol );
242 break;
243 case ShapeConst.SHAPE_TYPE_MULTIPOINT:
244 style = createPointStyle( legend, filterCol );
245 break;
246 default:
247 throw new Exception( "unknown geometry type: " + geoType );
248 }
249 return style;
250 }
251
252 /**
253 * creates a <tt>StyledLayerDescriptor</tt> from the avl file assigned to the instace of a
254 * <tt>AVLReader</tt>. The returned instance of a <tt>StyledLayerDescriptor</tt> just
255 * contains one style that may containes several <tt>Rule</tt>s
256 *
257 * @return a <tt>StyledLayerDescriptor</tt> created from the avl file assigned to the instace
258 * of a <tt>AVLReader</tt>. The returned instance of a <tt>StyledLayerDescriptor</tt>
259 * just contains one style that may containes several <tt>Rule</tt>s
260 * @throws IOException
261 * @throws Exception
262 */
263 public StyledLayerDescriptor getStyledLayerDescriptor()
264 throws IOException, Exception {
265 AbstractStyle style = getStyle();
266 String[] t = StringTools.toArray( fileRootName, "/", false );
267 String name = "default:" + t[t.length - 1];
268 AbstractLayer layer = new NamedLayer( name, null, new AbstractStyle[] { style } );
269 return new StyledLayerDescriptor( new AbstractLayer[] { layer }, "1.0.0" );
270 }
271
272 /**
273 * @return parse a string and return array of blocks between braces "(" and ")". It accounts for
274 * braces in quoted strings.
275 *
276 * @param s
277 * string to parse
278 */
279 public static String[] splitavl( String s ) {
280 if ( s == null || s.equals( "" ) ) {
281 return new String[0];
282 }
283
284 Pattern pat = Pattern.compile( "\\(([^)\"]|\"[^\"]*\")*\\)" );
285 Matcher mat = pat.matcher( s );
286 int prevend = 0;
287 ArrayList<String> vec = new ArrayList<String>();
288 while ( mat.find() ) {
289 int start = mat.start();
290 int end = mat.end();
291 if ( prevend < start - 1 ) {
292 String str = s.substring( prevend, start ).trim();
293 if ( str.length() > 0 ) {
294 vec.add( str );
295 }
296 }
297 String str = s.substring( start + 1, end - 1 ).trim();
298 if ( str.length() > 0 ) {
299 vec.add( str );
300 }
301 prevend = end;
302 }
303 if ( prevend < s.length() - 1 ) {
304 String str = s.substring( prevend ).trim();
305 if ( str.length() > 0 ) {
306 vec.add( str );
307 }
308 }
309
310 // no value selected
311 if ( vec.size() == 0 ) {
312 return new String[0];
313 }
314
315 return vec.toArray( new String[vec.size()] );
316 }
317
318 private int getGeometryType()
319 throws IOException {
320 MainFile mf = new MainFile( fileRootName );
321 int type = mf.getShapeTypeByRecNo( 1 );
322 mf.close();
323 return type;
324 }
325
326 /**
327 * creates a <tt>Style</tt>. For each class/child contained in a avl file one <tt>Rule</tt>
328 * will be created
329 *
330 * @param legend
331 * @param filterCol
332 * @return a <tt>Style</tt>.
333 */
334 // private AbstractStyle[] createPointStyles( Map legend, String filterCol ) {
335 // AbstractStyle[] styles = null;
336 // return styles;
337 // }
338 /**
339 * creates a <tt>Style</tt>. For each class/child contained in a avl file one <tt>Rule</tt>
340 * will be created
341 *
342 * @param legend
343 * @param filterCol
344 * @return a <tt>Style</tt>.
345 */
346 private AbstractStyle createPointStyle( Map legend, String filterCol )
347 throws FilterConstructionException {
348 try {
349 cl = new AVLPointSymbolCodeList();
350 } catch ( Exception e ) {
351 e.printStackTrace();
352 }
353 String tmp = (String) legend.get( "Symbols" );
354 Map block = blocks.get( "SymList." + tmp );
355 List classes = (List) legend.get( "Class" );
356 List children = (List) block.get( "Child" );
357
358 List<Rule> list = new ArrayList<Rule>( classes.size() );
359 for ( int i = 0; i < classes.size(); i++ ) {
360 String clNo = (String) classes.get( i );
361 Map clss = blocks.get( "LClass." + clNo );
362 String childNo = (String) children.get( i );
363 Map<String, Object> child = blocks.get( "CMkSym." + childNo );
364 Rule rule = null;
365 if ( child == null ) {
366 child = blocks.remove( "BMkSym." + childNo );
367 rule = createSimplePointRule( clss, child, filterCol );
368 } else {
369 rule = createComplexPointRule( clss, child, filterCol );
370 }
371 if ( rule != null ) {
372 list.add( rule );
373 }
374 }
375 Rule[] rules = list.toArray( new Rule[list.size()] );
376 FeatureTypeStyle fts = StyleFactory.createFeatureTypeStyle( rules );
377
378 String[] t = StringTools.toArray( fileRootName, "/", false );
379 String name = "default:" + t[t.length - 1];
380 return StyleFactory.createStyle( name, null, null, fts );
381 }
382
383 /**
384 * creates a Style for a line symbol
385 *
386 * @param clss
387 * @param child
388 * @return a Style for a line symbol
389 */
390 private Rule createSimplePointRule( Map clss, Map<String, Object> child, String filterCol ) {
391
392 if ( clss.get( "IsNoData" ) != null ) {
393 return null;
394 }
395
396 String label = (String) clss.get( "Label" );
397 label = StringTools.validateString( label, "\"" );
398 Filter filter = createFilter( clss, filterCol );
399 // get foreground color
400 String clrIdx = (String) child.get( "Color" );
401 Map<String, Object> color = blocks.get( "TClr." + clrIdx );
402 double fgOpacity = 1f;
403 if ( color != null && "\"Transparent\"".equals( color.get( "Name" ) ) ) {
404 fgOpacity = 0f;
405 }
406 Color fgColor = createColor( color );
407 if ( fgColor == null ) {
408 fgColor = Color.BLACK;
409 }
410 // get background color (what ever this means)
411 clrIdx = (String) child.get( "BgColor" );
412 color = blocks.get( "TClr." + clrIdx );
413 double bgOpacity = 1f;
414 if ( color != null && "\"Transparent\"".equals( color.get( "Name" ) ) ) {
415 bgOpacity = 0f;
416 }
417 Color bgColor = createColor( color );
418 if ( bgColor == null ) {
419 bgColor = Color.BLACK;
420 }
421
422 double size = Double.parseDouble( (String) child.get( "Size" ) );
423 double rotation = Double.parseDouble( (String) child.get( "Angle" ) );
424
425 // creation of a font from a avl file is a triky thing because
426 // esri uses their own font names and codes
427 // --> don' know if this works
428 String fntIdx = (String) child.get( "Font" );
429 Map fntMap = blocks.get( "NFont." + fntIdx );
430 Font font = createFont( fntMap );
431 PointPlacement pp = StyleFactory.createPointPlacement();
432 LabelPlacement labelPlacement = StyleFactory.createLabelPlacement( pp );
433 TextSymbolizer textSym = StyleFactory.createTextSymbolizer( fgColor, font, filterCol, labelPlacement );
434
435 String patternIdx = (String) ( (ArrayList) child.get( "Pattern" ) ).get( 0 );
436 String symbol = cl.getSymbol( patternIdx );
437
438 // create a Mark with a stroke and fill to controll both
439 // opacities
440 Stroke stroke = StyleFactory.createStroke( fgColor, 1, fgOpacity, null, "mitre", "butt" );
441 Fill fill = StyleFactory.createFill( bgColor, bgOpacity );
442 Mark mark = StyleFactory.createMark( symbol, fill, stroke );
443
444 Graphic graphic = StyleFactory.createGraphic( null, mark, 1, size, rotation );
445 PointSymbolizer pointSym = StyleFactory.createPointSymbolizer( graphic );
446
447 return StyleFactory.createRule( new Symbolizer[] { pointSym, textSym }, label, label, "", null, filter, false,
448 0, 9E99 );
449 }
450
451 private Rule createComplexPointRule( Map clss, Map<String, Object> child, String filterCol )
452 throws FilterConstructionException {
453
454 if ( clss.get( "IsNoData" ) != null ) {
455 return null;
456 }
457
458 String tmp = (String) child.get( "Symbols" );
459 Map block = blocks.get( "SymList." + tmp );
460 List children = (List) block.get( "Child" );
461
462 List<Symbolizer> smbls = new ArrayList<Symbolizer>();
463 for ( int i = 0; i < children.size(); i++ ) {
464 String childNo = (String) children.get( i );
465 Map child_ = blocks.get( "CMkSym." + childNo );
466 Rule rule = null;
467 if ( child_ == null ) {
468 child = blocks.remove( "BMkSym." + childNo );
469 rule = createSimplePointRule( clss, child, filterCol );
470 } else {
471 rule = createComplexPointRule( clss, child, filterCol );
472 }
473 Symbolizer[] sym = rule.getSymbolizers();
474 for ( int j = 0; j < sym.length; j++ ) {
475 smbls.add( sym[j] );
476 }
477 }
478 Symbolizer[] sym = new Symbolizer[smbls.size()];
479 sym = smbls.toArray( sym );
480
481 String label = (String) clss.get( "Label" );
482 label = StringTools.validateString( label, "\"" );
483 Filter filter = createFilter( clss, filterCol );
484
485 return StyleFactory.createRule( sym, label, label, "", null, filter, false, 0, 9E99 );
486 }
487
488 private Font createFont( Map fntMap ) {
489 String idx = (String) fntMap.get( "Family" );
490 String family = (String) blocks.get( "AVStr." + idx ).get( "S" );
491 idx = (String) fntMap.get( "Name" );
492 String name = (String) blocks.get( "AVStr." + idx ).get( "S" );
493 idx = (String) fntMap.get( "Style" );
494 String style = (String) blocks.get( "AVStr." + idx ).get( "S" );
495 String weight = (String) fntMap.get( "Weight" );
496 String wideness = (String) fntMap.get( "Wideness" );
497
498 boolean italic = style.equals( "Italic" );
499 boolean bold = Integer.parseInt( weight ) > 1;
500
501 return StyleFactory.createFont( family, italic, bold, 12 );
502 }
503
504 /**
505 * creates a <tt>Style</tt>. For each class/child contained in a avl file one <tt>Rule</tt>
506 * will be created
507 *
508 * @param legend
509 * @param filterCol
510 * @return a <tt>Style</tt>.
511 */
512 private AbstractStyle createLinesStyle( Map legend, String filterCol ) {
513 String tmp = (String) legend.get( "Symbols" );
514 Map block = blocks.get( "SymList." + tmp );
515 List classes = (List) legend.get( "Class" );
516 List children = (List) block.get( "Child" );
517 List<Rule> list = new ArrayList<Rule>( classes.size() );
518 for ( int i = 0; i < classes.size(); i++ ) {
519 String clNo = (String) classes.get( i );
520 Map clss = blocks.get( "LClass." + clNo );
521 String childNo = (String) children.get( i );
522 Map<String, Object> child = blocks.get( "BLnSym." + childNo );
523
524 if ( child == null ) {
525 // won't be treated correctly because we can't transform
526 // lines with sambols at the moment
527 child = blocks.get( "CLnSym." + childNo );
528 }
529 Rule rule = createLineRule( clss, child, filterCol );
530 if ( rule != null ) {
531 list.add( rule );
532 }
533 }
534 Rule[] rules = list.toArray( new Rule[list.size()] );
535 FeatureTypeStyle fts = StyleFactory.createFeatureTypeStyle( rules );
536
537 String[] t = StringTools.toArray( fileRootName, "/", false );
538 String name = "default:" + t[t.length - 1];
539 return StyleFactory.createStyle( name, null, null, fts );
540 }
541
542 /**
543 * creates a Style for a line symbol
544 *
545 * @param clss
546 * @param child
547 * @return a Style for a line symbol
548 */
549 private Rule createLineRule( Map clss, Map<String, Object> child, String filterCol ) {
550
551 if ( clss.get( "IsNoData" ) != null ) {
552 return null;
553 }
554
555 String label = (String) clss.get( "Label" );
556 label = StringTools.validateString( label, "\"" );
557 Filter filter = createFilter( clss, filterCol );
558
559 String clrIdx = (String) child.get( "Color" );
560 Map<String, Object> color = blocks.get( "TClr." + clrIdx );
561 double opacity = 1f;
562 if ( color != null && "\"Transparent\"".equals( color.get( "Name" ) ) && color.size() > 0 ) {
563 opacity = 0f;
564 }
565 Color colour = createColor( color );
566 if ( colour == null ) {
567 colour = Color.BLACK;
568 }
569
570 double width = 1.0; // default Width
571 if ( child.get( "Width" ) != null ) {
572 width = Double.parseDouble( (String) child.get( "Width" ) ) + width;
573 }
574 // double width = Double.parseDouble( (String)child.get("Width") ) + 1;
575 List<String> pl = (List<String>) child.get( "Pattern" );
576
577 if ( child.get( "Pattern" ) == null ) { // create a default pattern List if
578 // it is null
579 pl = new ArrayList<String>();
580 for ( int i = 0; i < 16; i++ ) { // Fill the default List with
581 // default values "0.00000000000000"
582 pl.add( "0.00000000000000" );
583 }
584 }
585
586 // List pl = (List)child.get("Pattern");
587 float[] dashArray = createDashArray( pl );
588 Stroke stroke = StyleFactory.createStroke( colour, width, opacity, dashArray, "mitre", "butt" );
589 LineSymbolizer lineSym = StyleFactory.createLineSymbolizer( stroke );
590
591 return StyleFactory.createRule( new Symbolizer[] { lineSym }, label, label, "", null, filter, false, 0, 9E99 );
592 }
593
594 /**
595 * creates a <tt>Style</tt>. For each class/child contained in a avl file one <tt>Rule</tt>
596 * will be created
597 *
598 * @param legend
599 * @param filterCol
600 * @return a <tt>Style</tt>.
601 */
602 private AbstractStyle createPolygonStyle( Map legend, String filterCol )
603 throws Exception {
604 String tmp = (String) legend.get( "Symbols" );
605 Map block = blocks.get( "SymList." + tmp );
606 List classes = (List) legend.get( "Class" );
607 List children = (List) block.get( "Child" );
608 List<Rule> list = new ArrayList<Rule>( classes.size() );
609 for ( int i = 0; i < classes.size(); i++ ) {
610 String clNo = (String) classes.get( i );
611 Map clss = blocks.get( "LClass." + clNo );
612 String childNo = (String) children.get( i );
613 Map<String, Object> child = blocks.get( "BShSym." + childNo );
614 Rule rule = null;
615 if ( child == null ) {
616 // VShSym is a vector polygon fill
617 child = blocks.get( "VShSym." + childNo );
618 rule = createPolygonVecRule( clss, child, filterCol );
619 } else {
620 rule = createPolygonBMPRule( clss, child, filterCol );
621 }
622 if ( rule != null ) {
623 list.add( rule );
624 }
625 // TODO
626 // write special method for vector polygon fill
627 }
628 Rule[] rules = list.toArray( new Rule[list.size()] );
629 FeatureTypeStyle fts = StyleFactory.createFeatureTypeStyle( rules );
630
631 String[] t = StringTools.toArray( fileRootName, "/", false );
632 String name = "default:" + t[t.length - 1];
633 return StyleFactory.createStyle( name, null, null, fts );
634 }
635
636 /**
637 * creates a Style for a line symbol
638 *
639 * @param clss
640 * @param child
641 * @return a Style for a line symbol
642 */
643 private Rule createPolygonBMPRule( Map clss, Map<String, Object> child, String filterCol )
644 throws Exception {
645
646 if ( clss.get( "IsNoData" ) != null ) {
647 return null;
648 }
649
650 String label = (String) clss.get( "Label" );
651 label = StringTools.validateString( label, "\"" );
652
653 Filter filter = null;
654 if ( filterCol != null ) {
655 filter = createFilter( clss, filterCol );
656 }
657 // get foreground color
658 String clrIdx = (String) child.get( "Color" );
659 Map<String, Object> color = blocks.get( "TClr." + clrIdx );
660 double opacity = 1f;
661 if ( color != null && "\"Transparent\"".equals( color.get( "Name" ) ) ) {
662 opacity = 0f;
663 }
664
665 Color fgColor = createColor( color );
666 if ( fgColor == null ) {
667 fgColor = Color.BLACK;
668 }
669 // get color of the outlining stroke
670 clrIdx = (String) child.get( "OutlineColor" );
671 color = blocks.get( "TClr." + clrIdx );
672 double outLOpacity = 1f;
673 if ( color != null && "\"Transparent\"".equals( color.get( "Name" ) ) ) {
674 outLOpacity = 0f;
675 }
676 Color outLColor = createColor( color );
677 if ( outLColor == null ) {
678 outLColor = Color.BLACK;
679 }
680 // get background color
681 clrIdx = (String) child.get( "BgColor" );
682 color = blocks.get( "TClr." + clrIdx );
683 double bgOpacity = 1f;
684 if ( color != null && "\"Transparent\"".equals( color.get( "Name" ) ) ) {
685 bgOpacity = 0f;
686 }
687 Color bgColor = createColor( color );
688
689 // create fill pattern as an image that will be referenced as
690 // external graphic
691 String stippleIdx = (String) child.get( "Stipple" );
692 String src = null;
693 if ( stippleIdx != null ) {
694 Map stipple = blocks.get( "Stipple." + stippleIdx );
695 src = createExternalGraphicFromStipple( stipple, label, fgColor, bgColor );
696 }
697
698 double width = Double.parseDouble( (String) child.get( "OutlineWidth" ) ) + 1;
699 Stroke stroke = StyleFactory.createStroke( outLColor, width, outLOpacity, null, "mitre", "butt" );
700 Fill fill = null;
701 if ( stippleIdx != null ) {
702 ExternalGraphic eg = StyleFactory.createExternalGraphic( "file:///" + src, "image/gif" );
703 Graphic graph = StyleFactory.createGraphic( eg, null, opacity, 10, 0 );
704 GraphicFill gf = StyleFactory.createGraphicFill( graph );
705 fill = StyleFactory.createFill( fgColor, opacity, gf );
706 } else {
707 fill = StyleFactory.createFill( fgColor, opacity );
708 }
709 PolygonSymbolizer polySym = StyleFactory.createPolygonSymbolizer( stroke, fill );
710 return StyleFactory.createRule( new Symbolizer[] { polySym }, label, label, "", null, filter, false, 0, 9E99 );
711 }
712
713 /**
714 * creates a Style for a line symbol
715 *
716 * @param clss
717 * @param child
718 * @return a Style for a line symbol
719 */
720 private Rule createPolygonVecRule( Map clss, Map<String, Object> child, String filterCol )
721 throws Exception {
722
723 if ( clss.get( "IsNoData" ) != null ) {
724 return null;
725 }
726
727 String label = (String) clss.get( "Label" );
728 label = StringTools.validateString( label, "\"" );
729
730 Filter filter = null;
731 if ( filterCol != null ) {
732 filter = createFilter( clss, filterCol );
733 }
734 // get foreground color
735 String clrIdx = (String) child.get( "Color" );
736 Map<String, Object> color = blocks.get( "TClr." + clrIdx );
737 double opacity = 1f;
738 if ( color != null && "\"Transparent\"".equals( color.get( "Name" ) ) ) {
739 opacity = 0f;
740 }
741 Color fgColor = createColor( color );
742 if ( fgColor == null ) {
743 fgColor = Color.BLACK;
744 }
745 // get color of the outlining stroke
746 clrIdx = (String) child.get( "OutlineColor" );
747 color = blocks.get( "TClr." + clrIdx );
748 double outLOpacity = 1f;
749 if ( color != null && "\"Transparent\"".equals( color.get( "Name" ) ) ) {
750 outLOpacity = 0f;
751 }
752 Color outLColor = createColor( color );
753 if ( outLColor == null ) {
754 outLColor = Color.BLACK;
755 }
756 // get background color
757 clrIdx = (String) child.get( "BgColor" );
758 color = blocks.get( "TClr." + clrIdx );
759 double bgOpacity = 1f;
760 if ( color != null && "\"Transparent\"".equals( color.get( "Name" ) ) ) {
761 bgOpacity = 0f;
762 }
763 Color bgColor = createColor( color );
764
765 // create fill pattern as an image that will be referenced as
766 // external graphic
767 String stippleIdx = (String) child.get( "Stipple" );
768 String src = null;
769 if ( stippleIdx != null ) {
770 Map stipple = blocks.get( "Stipple." + stippleIdx );
771 src = createExternalGraphicFromStipple( stipple, label, fgColor, bgColor );
772 }
773
774 double width = Double.parseDouble( (String) child.get( "OutlineWidth" ) ) + 1;
775 Stroke stroke = StyleFactory.createStroke( outLColor, width, outLOpacity, null, "mitre", "butt" );
776 Fill fill = null;
777 if ( stippleIdx != null ) {
778 ExternalGraphic eg = StyleFactory.createExternalGraphic( "file:///" + src, "image/gif" );
779 Graphic graph = StyleFactory.createGraphic( eg, null, opacity, 10, 0 );
780 GraphicFill gf = StyleFactory.createGraphicFill( graph );
781 fill = StyleFactory.createFill( fgColor, opacity, gf );
782 } else {
783 fill = StyleFactory.createFill( fgColor, opacity );
784 }
785 PolygonSymbolizer polySym = StyleFactory.createPolygonSymbolizer( stroke, fill );
786 return StyleFactory.createRule( new Symbolizer[] { polySym }, label, label, "", null, filter, false, 0, 9E99 );
787 }
788
789 /**
790 * creates an image from a stipple and stores it as a gif image. The method returns the full
791 * name of the stored image.
792 *
793 * @param stipple
794 * @return an image from a stipple and stores it as a gif image. The method returns the full
795 * name of the stored image.
796 */
797 private String createExternalGraphicFromStipple( Map stipple, String label, Color fg, Color bg )
798 throws Exception {
799
800 if ( label != null ) {
801 label = label.replace( ' ', '_' );
802 label = label.replace( '.', '_' );
803 label = label.replace( ';', '_' );
804 label = label.replace( ',', '_' );
805 label = label.replace( '-', '_' );
806 label = label.replace( ':', '_' );
807 }
808 String tmp = (String) stipple.get( "Columns" );
809 int cols = Integer.parseInt( tmp );
810 tmp = (String) stipple.get( "Rows" );
811 int rows = Integer.parseInt( tmp );
812
813 List bList = (List) stipple.get( "Bits" );
814 StringBuffer bStr = new StringBuffer( 1000 );
815 for ( int i = 0; i < bList.size(); i++ ) {
816 String[] t = StringTools.toArray( ( (String) bList.get( i ) ).trim(), " ", false );
817 for ( int j = 0; j < t.length; j++ ) {
818 bStr.append( t[j] );
819 }
820 }
821
822 char[] ch = bStr.toString().toCharArray();
823
824 BufferedImage bi = createFillPattern( cols, rows, ch, fg, bg );
825
826 final String format = "gif";
827
828 String[] t = StringTools.toArray( fileRootName, "/", false );
829 String base = t[t.length - 1];
830 StringBuffer fileName = new StringBuffer();
831 fileName.append( targetDir ).append( base );
832 if ( label != null ) {
833 fileName.append( "_" ).append( label ).append( "." ).append( format );
834 } else {
835 fileName.append( "." ).append( format );
836 }
837
838 // FileOutputStream fos = new FileOutputStream( targetDir + base + '_' + label + "." +
839 // format );
840 FileOutputStream fos = new FileOutputStream( fileName.toString() );
841 ImageUtils.saveImage( bi, fos, format, 1.0f );
842 // Encoders.encodeGif(fos,bi);
843 fos.close();
844
845 if ( targetDir.startsWith( "/" ) ) {
846 if ( label != null ) {
847 return targetDir.substring( 1, targetDir.length() ) + base + '_' + label + "." + format;
848 } else {
849 return targetDir.substring( 1, targetDir.length() ) + base + "." + format;
850 }
851 } else {
852 if ( label != null ) {
853 return targetDir + base + '_' + label + "." + format;
854 } else {
855 return targetDir + base + "." + format;
856 }
857
858 }
859
860 }
861
862 /**
863 * creates a <tt>BufferedImage</tt> using the stipple contained in the passed char array.
864 *
865 * @param cols
866 * @param rows
867 * @param ch
868 * @return a <tt>BufferedImage</tt> using the stipple contained in the passed char array.
869 */
870 private BufferedImage createFillPattern( int cols, int rows, char[] ch, Color fg, Color bg ) {
871 BufferedImage bi = new BufferedImage( cols, rows, BufferedImage.TYPE_INT_ARGB );
872 int cntChar = 0;
873 byte[] bTmp = null;
874 char chr = ' ';
875 int hexCnt = 0;
876 if ( cols % 8 != 0 ) {
877 hexCnt = ( cols / 8 + 1 ) * 8;
878 } else {
879 hexCnt = cols;
880 }
881 for ( int i = 0; i < rows; i++ ) {
882 for ( int j = 0; j < hexCnt; j++ ) {
883 if ( j % 4 == 0 ) {
884 chr = ch[cntChar++];
885 bTmp = getBits( chr );
886 }
887 if ( j < cols ) {
888 if ( bTmp[j % 4] == 0 ) {
889 if ( bg != null ) {
890 bi.setRGB( j, i, bg.getRGB() );
891 }
892 } else {
893 bi.setRGB( j, i, fg.getRGB() );
894 }
895 }
896 }
897 }
898 return bi;
899 }
900
901 private byte[] getBits( int ch ) {
902 switch ( ch ) {
903 case '0':
904 return new byte[] { 0, 0, 0, 0 };
905 case '1':
906 return new byte[] { 0, 0, 0, 1 };
907 case '2':
908 return new byte[] { 0, 0, 1, 0 };
909 case '3':
910 return new byte[] { 0, 0, 1, 1 };
911 case '4':
912 return new byte[] { 0, 1, 0, 0 };
913 case '5':
914 return new byte[] { 0, 1, 0, 1 };
915 case '6':
916 return new byte[] { 0, 1, 1, 0 };
917 case '7':
918 return new byte[] { 0, 1, 1, 1 };
919 case '8':
920 return new byte[] { 1, 0, 0, 0 };
921 case '9':
922 return new byte[] { 1, 0, 0, 1 };
923 case 'a':
924 return new byte[] { 1, 0, 1, 0 };
925 case 'b':
926 return new byte[] { 1, 0, 1, 1 };
927 case 'c':
928 return new byte[] { 1, 1, 0, 0 };
929 case 'd':
930 return new byte[] { 1, 1, 0, 1 };
931 case 'e':
932 return new byte[] { 1, 1, 1, 0 };
933 case 'f':
934 return new byte[] { 1, 1, 1, 1 };
935 default:
936 return new byte[] { 0, 0, 0, 0 };
937 }
938 }
939
940 /**
941 * @return creates a dasharray for constructing a stroke from the pattern entries of a avl
942 * xxxSym. block
943 *
944 * @param pl
945 */
946 private float[] createDashArray( List<String> pl ) {
947 int cnt = 0;
948 for ( int i = 0; i < pl.size(); i++ ) {
949 if ( Float.parseFloat( pl.get( i ) ) > 0 ) {
950 cnt++;
951 } else {
952 break;
953 }
954 }
955 float[] pattern = null;
956 if ( cnt > 0 ) {
957 pattern = new float[cnt];
958 for ( int i = 0; i < pattern.length; i++ ) {
959 pattern[i] = Float.parseFloat( pl.get( i ) );
960 }
961 }
962 return pattern;
963 }
964
965 /**
966 * creates a AWT color from a val color block
967 *
968 * @param color
969 * @return a AWT color from a val color block
970 */
971 private Color createColor( Map<String, Object> color ) {
972 StringBuffer hex = new StringBuffer( "0x" );
973 if ( color != null && !"\"Transparent\"".equals( color.get( "Name" ) ) ) {
974 String red = (String) color.get( "Red" );
975 if ( red == null )
976 red = "0x0000";
977 int c = (int) ( ( Integer.decode( red ).intValue() / 65535f ) * 255 );
978 if ( c < 15 ) {
979 hex.append( 0 );
980 }
981 hex.append( Integer.toHexString( c ) );
982 String green = (String) color.get( "Green" );
983 if ( green == null )
984 green = "0x0000";
985 c = (int) ( ( Integer.decode( green ).intValue() / 65535f ) * 255 );
986 if ( c < 15 ) {
987 hex.append( 0 );
988 }
989 hex.append( Integer.toHexString( c ) );
990 String blue = (String) color.get( "Blue" );
991 if ( blue == null )
992 blue = "0x0000";
993 c = (int) ( ( Integer.decode( blue ).intValue() / 65535f ) * 255 );
994 if ( c < 15 ) {
995 hex.append( 0 );
996 }
997 hex.append( Integer.toHexString( c ) );
998 } else {
999 // hex.append("000000");
1000 return null;
1001 }
1002 return Color.decode( hex.toString() );
1003 }
1004
1005 private Filter createFilter( Map clss, String filterCol ) {
1006
1007 if ( clss.get( "Label" ) == null ) {
1008 return null;
1009 }
1010 Filter filter = null;
1011
1012 String maxN = (String) clss.get( "MaxStr" );
1013 String minN = (String) clss.get( "MinStr" );
1014 if ( maxN != null && minN != null ) {
1015 filter = createStringFilter( clss, filterCol );
1016 } else {
1017 filter = createNumberFilter( clss, filterCol );
1018 }
1019
1020 return filter;
1021 }
1022
1023 private Filter createStringFilter( Map clss, String filterCol ) {
1024 Filter filter;
1025 Operation oper = null;
1026 String maxN = (String) clss.get( "MaxStr" );
1027 String minN = (String) clss.get( "MinStr" );
1028 maxN = maxN.substring( 1, maxN.length() - 1 );
1029 minN = minN.substring( 1, minN.length() - 1 );
1030 if ( maxN.equals( minN ) ) {
1031 oper = new PropertyIsCOMPOperation( OperationDefines.PROPERTYISEQUALTO,
1032 new PropertyName( new QualifiedName( filterCol ) ), new Literal( minN ) );
1033 } else {
1034 ArrayList<Operation> list = new ArrayList<Operation>();
1035 Operation op = new PropertyIsCOMPOperation( OperationDefines.PROPERTYISLESSTHANOREQUALTO,
1036 new PropertyName( new QualifiedName( filterCol ) ),
1037 new Literal( maxN ) );
1038 list.add( op );
1039 op = new PropertyIsCOMPOperation( OperationDefines.PROPERTYISGREATERTHANOREQUALTO,
1040 new PropertyName( new QualifiedName( filterCol ) ), new Literal( minN ) );
1041 list.add( op );
1042
1043 oper = new LogicalOperation( OperationDefines.AND, list );
1044 }
1045 filter = new ComplexFilter( oper );
1046 return filter;
1047 }
1048
1049 private Filter createNumberFilter( Map clss, String filterCol ) {
1050
1051 String maxN = (String) clss.get( "MaxNum" );
1052 String minN = (String) clss.get( "MinNum" );
1053 if ( maxN == null ) {
1054 maxN = "9E99";
1055 }
1056 if ( minN == null ) {
1057 minN = "-9E99";
1058 }
1059 double t1 = Double.parseDouble( minN );
1060 double t2 = Double.parseDouble( maxN );
1061 Operation oper = null;
1062 if ( t1 == t2 ) {
1063 // if t1 == t2 no range is defined and so an 'is equal to'
1064 // opertaion must be used
1065 if ( ( (int) t1 ) == t1 ) {
1066 // if no significant fraction values are present
1067 // cast the value to int
1068 oper = new PropertyIsCOMPOperation( OperationDefines.PROPERTYISEQUALTO,
1069 new PropertyName( new QualifiedName( filterCol ) ),
1070 new Literal( "" + ( (int) t1 ) ) );
1071 } else {
1072 oper = new PropertyIsCOMPOperation( OperationDefines.PROPERTYISEQUALTO,
1073 new PropertyName( new QualifiedName( filterCol ) ),
1074 new Literal( "" + t1 ) );
1075 }
1076 } else {
1077 // if t1 != t2 range of valid values is defined and so an so two
1078 // operation (one for each border of the range) are used
1079 ArrayList<Operation> list = new ArrayList<Operation>();
1080 Operation op = new PropertyIsCOMPOperation( OperationDefines.PROPERTYISLESSTHANOREQUALTO,
1081 new PropertyName( new QualifiedName( filterCol ) ),
1082 new Literal( maxN ) );
1083 list.add( op );
1084 op = new PropertyIsCOMPOperation( OperationDefines.PROPERTYISGREATERTHANOREQUALTO,
1085 new PropertyName( new QualifiedName( filterCol ) ), new Literal( minN ) );
1086 list.add( op );
1087
1088 oper = new LogicalOperation( OperationDefines.AND, list );
1089
1090 }
1091
1092 return new ComplexFilter( oper );
1093
1094 }
1095
1096 private static String[] getAVLFiles( String dir ) {
1097 File file = new File( dir );
1098 return file.list( new DFileFilter() );
1099
1100 }
1101
1102 private static void printHelp() {
1103
1104 System.out.println( "Converts ESRI *.avl files to OGC SLD documents. The current version of " );
1105 System.out.println( "this tool isn't able to convert each and every construction that is " );
1106 System.out.println( "possible with an *.avl file. But most of the common expressions will be mapped." );
1107 System.out.println( "Supported are *.avl files for point, lines and polygons." );
1108 System.out.println( "" );
1109 System.out.println( "-sourceFile -> full path to the *.avl file to be converted. " );
1110 System.out.println( " in the same directory a shapefile with the same name as the *.avl" );
1111 System.out.println( " file must exist! (conditional, -sourceFile or -sourceDir must " );
1112 System.out.println( " be defined)" );
1113 System.out.println( "-sourceDir -> directory containing one or more *.avl files. for each existing" );
1114 System.out.println( " *.avl file a shapefile with the same base name must exist. " );
1115 System.out.println( " (conditional, -sourceFile or -sourceDir must be defined)" );
1116 System.out.println( "-targetDir -> directory where the created SLD document(s) will be stored. (optional)" );
1117 System.out.println( "-h -> print this help" );
1118 }
1119
1120 /**
1121 *
1122 * @param args
1123 * @throws Exception
1124 */
1125 public static void main( String[] args )
1126 throws Exception {
1127
1128 Map<String, String> map = new HashMap<String, String>();
1129
1130 for ( int i = 0; i < args.length; i += 2 ) {
1131 map.put( args[i], args[i + 1] );
1132 }
1133
1134 if ( map.get( "-sourceFile" ) == null && map.get( "-sourceDir" ) == null && map.get( "-h" ) == null ) {
1135 System.out.println( "-sourceFile or -sourceDir must be defined!" );
1136 System.out.println();
1137 printHelp();
1138 System.exit( 1 );
1139 }
1140
1141 if ( map.get( "-h" ) != null ) {
1142 printHelp();
1143 System.exit( 0 );
1144 }
1145
1146 String targetDir = ".";
1147 String[] sourceFiles = null;
1148 if ( map.get( "-sourceFile" ) != null ) {
1149 sourceFiles = new String[] { map.get( "-sourceFile" ) };
1150 // set the default target directory to the sourceFile's directory
1151 targetDir = sourceFiles[0].substring( 0, sourceFiles[0].lastIndexOf( "/" ) );
1152 }
1153
1154 if ( sourceFiles == null ) {
1155 String sourceDir = map.get( "-sourceDir" );
1156 sourceFiles = getAVLFiles( sourceDir );
1157 for ( int i = 0; i < sourceFiles.length; i++ ) {
1158 sourceFiles[i] = sourceDir + '/' + sourceFiles[i];
1159 }
1160 // set the default target directory to the source directory
1161 targetDir = sourceDir;
1162
1163 }
1164
1165 // String targetDir = ".";
1166 if ( map.get( "-targetDir" ) != null ) {
1167 targetDir = map.get( "-targetDir" );
1168 }
1169
1170 for ( int i = 0; i < sourceFiles.length; i++ ) {
1171 System.out.println( "processing: " + sourceFiles[i] );
1172 int pos = sourceFiles[i].lastIndexOf( '.' );
1173 String file = sourceFiles[i].substring( 0, pos );
1174 AVL2SLD avl = new AVL2SLD( file, targetDir );
1175 avl.read();
1176 StyledLayerDescriptor sld = avl.getStyledLayerDescriptor();
1177 String[] t = StringTools.toArray( file, "/", false );
1178 FileWriter fos = new FileWriter( targetDir + '/' + t[t.length - 1] + ".xml" );
1179 fos.write( ( (Marshallable) sld ).exportAsXML() );
1180 fos.close();
1181 }
1182 }
1183
1184 /**
1185 *
1186 *
1187 * @version $Revision: 18195 $
1188 * @author <a href="mailto:poth@lat-lon.de">Andreas Poth</a>
1189 */
1190 private static class DFileFilter implements FilenameFilter {
1191 /**
1192 * @param f
1193 * @return true if accepted
1194 */
1195 public boolean accept( File f, String name ) {
1196 int pos = name.lastIndexOf( "." );
1197 String ext = name.substring( pos + 1 );
1198 return ext.toUpperCase().equals( "AVL" );
1199 }
1200 }
1201
1202 }