package com.ximple.eofms;
|
|
import java.io.File;
|
import java.io.FileInputStream;
|
import java.io.FileNotFoundException;
|
import java.io.FilenameFilter;
|
import java.io.IOException;
|
import java.io.UnsupportedEncodingException;
|
import java.net.MalformedURLException;
|
import java.net.URL;
|
import java.nio.channels.FileChannel;
|
import java.nio.charset.Charset;
|
import java.util.HashMap;
|
import java.util.List;
|
|
import org.apache.commons.collections.map.MultiValueMap;
|
import org.apache.commons.digester.Digester;
|
import org.apache.commons.digester.xmlrules.DigesterLoader;
|
import org.apache.commons.logging.Log;
|
import org.apache.commons.logging.LogFactory;
|
import org.geotools.feature.Feature;
|
import org.geotools.feature.FeatureType;
|
import org.geotools.feature.SimpleFeature;
|
import org.geotools.feature.FeatureCollection;
|
import org.geotools.feature.FeatureCollections;
|
import org.geotools.data.FeatureWriter;
|
import org.geotools.data.Transaction;
|
import org.geotools.data.FeatureStore;
|
import org.geotools.data.shapefile.ShapefileDataStore;
|
import org.xml.sax.SAXException;
|
|
import com.vividsolutions.jts.geom.GeometryFactory;
|
|
import com.ximple.eofms.filter.AbstractFLinkageDispatchableFilter;
|
import com.ximple.eofms.filter.ElementDispatcher;
|
import com.ximple.eofms.jobs.context.postgis.FeatureDgnConvertPostGISJobContext;
|
import com.ximple.eofms.util.FeatureTypeBuilderUtil;
|
import com.ximple.io.dgn7.ComplexElement;
|
import com.ximple.io.dgn7.Dgn7fileException;
|
import com.ximple.io.dgn7.Dgn7fileReader;
|
import com.ximple.io.dgn7.Element;
|
import com.ximple.io.dgn7.ElementType;
|
import com.ximple.io.dgn7.FrammeAttributeData;
|
import com.ximple.io.dgn7.Lock;
|
|
public class XElementParser implements Runnable
|
{
|
static Log logger = LogFactory.getLog(XElementParser.class);
|
static final GeometryFactory geometryFactory = new GeometryFactory();
|
|
static final boolean isCompactMode = true;
|
static final boolean postOutMode = true;
|
|
protected static final String ROOTDATAPATH = "DATAPATH";
|
|
protected static final String DEFAULT_DATAPATH = "G:\\Temp\\JobData\\tctpc";
|
protected static final String DEFAULT_DGNINPATH = "elmin";
|
protected static final String DEFAULT_DGNOUTPATH = "elmout";
|
protected static final String DEFAULT_SHPOUTPATH = "out";
|
|
private HashMap<String, String> dataConfig;
|
private ElementDispatcher elementDispatcher;
|
private MultiValueMap featuresContext = new MultiValueMap();
|
|
public static void main(String[] args)
|
{
|
XElementParser parser = new XElementParser();
|
parser.run();
|
}
|
|
public XElementParser()
|
{
|
initializeDataConfig();
|
}
|
|
private void initializeDataConfig()
|
{
|
dataConfig = new HashMap<String, String>();
|
dataConfig.put(ROOTDATAPATH, DEFAULT_DATAPATH);
|
|
elementDispatcher = createElementDispatcher();
|
|
FeatureTypeBuilderUtil.setNotAllowNull(true);
|
}
|
|
private ElementDispatcher createElementDispatcher()
|
{
|
try
|
{
|
URL rulesURL = ElementDispatcher.class.getResource("ElementDispatcherRules.xml");
|
assert rulesURL != null;
|
Digester digester = DigesterLoader.createDigester(rulesURL);
|
URL filterURL;
|
|
filterURL = FeatureDgnConvertPostGISJobContext.class.getResource("/conf/DefaultConvertShpFilter.xml");
|
|
assert filterURL != null;
|
return (ElementDispatcher) digester.parse(filterURL);
|
} catch (UnsupportedEncodingException e)
|
{
|
logger.info(e.getMessage(), e);
|
throw new RuntimeException(e.getMessage(), e);
|
} catch (MalformedURLException e)
|
{
|
logger.info(e.getMessage(), e);
|
throw new RuntimeException(e.getMessage(), e);
|
} catch (IOException e)
|
{
|
logger.info(e.getMessage(), e);
|
throw new RuntimeException(e.getMessage(), e);
|
} catch (SAXException e)
|
{
|
logger.info(e.getMessage(), e);
|
throw new RuntimeException(e.getMessage(), e);
|
}
|
}
|
|
public void run()
|
{
|
File rootDir = new File(dataConfig.get(ROOTDATAPATH));
|
File dataDir = new File(rootDir, DEFAULT_DGNINPATH);
|
if ((!dataDir.exists()) || (!dataDir.isDirectory()))
|
{
|
return;
|
}
|
|
File[] dataFiles = dataDir.listFiles(new FilenameFilter() {
|
public boolean accept(File dir, String name)
|
{
|
return name.toLowerCase().endsWith(".dgn");
|
}
|
});
|
|
for (File dataFile : dataFiles)
|
{
|
try
|
{
|
FileInputStream fs = new FileInputStream(dataFile);
|
FileChannel fc = fs.getChannel();
|
Dgn7fileReader reader = new Dgn7fileReader(fc, new Lock());
|
int count = 0;
|
Element lastComplex = null;
|
while (reader.hasNext())
|
{
|
Dgn7fileReader.Record record = reader.nextElement();
|
if (record.element() != null)
|
{
|
Element element = (Element) record.element();
|
ElementType type = element.getElementType();
|
|
if ((!type.isComplexElement()) && (!element.isComponentElement()))
|
{
|
if (lastComplex != null)
|
{
|
processFeatureElement(lastComplex);
|
lastComplex = null;
|
}
|
|
processFeatureElement(element);
|
} else if (element.isComponentElement())
|
{
|
if (lastComplex != null)
|
{
|
((ComplexElement) lastComplex).add(element);
|
}
|
} else if (type.isComplexElement())
|
{
|
if (lastComplex != null)
|
{
|
processFeatureElement(lastComplex);
|
}
|
lastComplex = element;
|
}
|
}
|
count++;
|
}
|
|
if (lastComplex != null)
|
{
|
processFeatureElement(lastComplex);
|
}
|
logger.debug("ElementRecord Count=" + count);
|
|
} catch (Dgn7fileException e)
|
{
|
logger.warn(e.getMessage(), e);
|
} catch (FileNotFoundException e)
|
{
|
logger.warn(e.getMessage(), e);
|
} catch (IOException e)
|
{
|
logger.warn(e.getMessage(), e);
|
}
|
}
|
|
if (postOutMode)
|
{
|
try
|
{
|
postProcessFeatureContext();
|
} catch (IOException e)
|
{
|
logger.warn(e.getMessage(), e);
|
} catch (IllegalAttributeException e)
|
{
|
logger.warn(e.getMessage(), e);
|
}
|
}
|
}
|
|
private void processFeatureElement(Element element)
|
{
|
if (element == null)
|
{
|
logger.warn("Unknown Element:" + null);
|
return;
|
}
|
|
// �P�_�O�_�ũM���
|
Feature feature = elementDispatcher.execute(element, false);
|
if (feature == null)
|
{
|
FrammeAttributeData linkage =
|
AbstractFLinkageDispatchableFilter.getFeatureLinkage(element);
|
if ((isCompactMode) && (linkage != null))
|
{
|
logger.warn("Unknown Element:" + element.getElementType().toString() +
|
":type=" + element.getType() + ":lv=" + element.getLevelIndex() + ":id=" +
|
(linkage.getFsc() + "|" + linkage.getComponentID()));
|
if (element instanceof ComplexElement)
|
{
|
ComplexElement complex = (ComplexElement) element;
|
logger.warn("----Complex Element size=" + complex.size());
|
}
|
|
manualElementProcess(element);
|
} else if (!isCompactMode) {
|
logger.warn("Unknown Element:" + element.getElementType().toString() +
|
":type=" + element.getType() + ":lv=" + element.getLevelIndex() + ":id=" +
|
(linkage == null ? "NULL" : (linkage.getFsc() + "|" + linkage.getComponentID())));
|
|
if (element instanceof ComplexElement)
|
{
|
ComplexElement complex = (ComplexElement) element;
|
logger.warn("----Complex Element size=" + complex.size());
|
}
|
}
|
|
return;
|
}
|
|
featuresContext.put(feature.getFeatureType(), feature);
|
}
|
|
private void manualElementProcess(Element element)
|
{
|
}
|
|
private void postProcessFeatureContext() throws IOException, IllegalAttributeException
|
{
|
if (featuresContext.size() == 0) return;
|
for (Object key : featuresContext.keySet())
|
{
|
FeatureType featureType = (FeatureType) key;
|
List elements = (List) featuresContext.get(key);
|
|
FeatureCollection features = FeatureCollections.newCollection();
|
features.addAll(elements);
|
createFeatureStore(featureType).addFeatures(features);
|
|
FeatureWriter writer = createFeatureWriter(featureType);
|
for (Object v : elements)
|
{
|
Feature feature1 = (Feature) v;
|
Object[] attrs = feature1.getAttributes(null);
|
if (attrs != null)
|
((SimpleFeature) writer.next()).setAttributes(attrs);
|
|
}
|
writer.close();
|
}
|
}
|
|
private FeatureStore createFeatureStore(FeatureType featureType) throws IOException
|
{
|
File sfile = new File(getDataOutPath() + File.separator + featureType.getTypeName());
|
|
ShapefileDataStore shapefileDataStore = null;
|
boolean existFile = sfile.exists();
|
|
shapefileDataStore = new ShapefileDataStore(sfile.toURI().toURL(),
|
true, Charset.forName("UTF-8"));
|
|
if (!existFile)
|
{
|
shapefileDataStore.createSchema(featureType);
|
}
|
return (FeatureStore) shapefileDataStore.getFeatureSource(featureType.getTypeName());
|
}
|
private FeatureWriter createFeatureWriter(FeatureType featureType) throws IOException
|
{
|
File sfile = new File(getDataOutPath() + File.separator + featureType.getTypeName());
|
|
ShapefileDataStore shapefileDataStore = null;
|
boolean existFile = sfile.exists();
|
|
shapefileDataStore = new ShapefileDataStore(sfile.toURI().toURL(),
|
true, Charset.forName("UTF-8"));
|
|
FeatureWriter writer;
|
if (!existFile)
|
{
|
shapefileDataStore.createSchema(featureType);
|
writer = shapefileDataStore.getFeatureWriter(featureType.getTypeName(), Transaction.AUTO_COMMIT);
|
} else {
|
writer = shapefileDataStore.getFeatureWriterAppend(featureType.getTypeName(), Transaction.AUTO_COMMIT);
|
}
|
|
return writer;
|
}
|
|
public String getDataOutPath()
|
{
|
File rootDir = new File(dataConfig.get(ROOTDATAPATH));
|
File dataDir = new File(rootDir, DEFAULT_SHPOUTPATH);
|
return dataDir.toString();
|
}
|
|
}
|
