async private Task ExportDatasetObject_fdb(object datasetObject)
{
if (datasetObject is IFeatureDataset)
{
IFeatureDataset dataset = (IFeatureDataset)datasetObject;
foreach (IDatasetElement element in await dataset.Elements())
{
if (element is IFeatureLayer)
{
await ExportDatasetObject(((IFeatureLayer)element).FeatureClass);
}
}
}
if (datasetObject is IFeatureClass)
{
if (_fdbExport == null)
{
_fdbExport = new FDBImport();
}
else
{
MessageBox.Show("ERROR: Import already runnung");
return;
}
FeatureClassImportProgressReporter reporter = await FeatureClassImportProgressReporter.CreateAsync(_fdbExport, (IFeatureClass)datasetObject);
FormTaskProgress progress = new FormTaskProgress(reporter, ExportAsync_fdb(datasetObject));
progress.Text = "Export Features: " + ((IFeatureClass)datasetObject).Name;
progress.ShowDialog();
_fdbExport = null;
}
}
async private Task ImportDatasetObject(object datasetObject, bool schemaOnly)
{
if (datasetObject is IFeatureDataset)
{
IFeatureDataset dataset = (IFeatureDataset)datasetObject;
foreach (IDatasetElement element in await dataset.Elements())
{
if (element is IFeatureLayer)
{
await ImportDatasetObject(((IFeatureLayer)element).FeatureClass, schemaOnly);
}
}
}
if (datasetObject is IFeatureClass)
{
if (_import == null)
{
_import = new FeatureImport();
}
else
{
MessageBox.Show("ERROR: Import already runnung");
return;
}
_import.SchemaOnly = schemaOnly;
FeatureClassImportProgressReporter reporter = await FeatureClassImportProgressReporter.Create(_import, (IFeatureClass)datasetObject);
FormTaskProgress progress = new FormTaskProgress(reporter, ImportAsync(datasetObject));
progress.Text = "Import Featureclass: " + ((IFeatureClass)datasetObject).Name;
progress.ShowDialog();
_import = null;
}
if (datasetObject is FeatureClassListViewItem)
{
if (_import == null)
{
_import = new FeatureImport();
}
else
{
MessageBox.Show("ERROR: Import already runnung");
return;
}
_import.SchemaOnly = schemaOnly;
FeatureClassImportProgressReporter reporter = await FeatureClassImportProgressReporter.Create(_import, ((FeatureClassListViewItem)datasetObject).FeatureClass);
FormTaskProgress progress = new FormTaskProgress(reporter, ImportAsync(datasetObject));
progress.Text = "Import Featureclass: " + ((FeatureClassListViewItem)datasetObject).Text;
progress.ShowDialog();
_import = null;
}
}
async private Task MakeGui()
{
cmbDatabaseViews.Items.Clear();
cmbRefFeatureClass.Items.Clear();
if (_dataset == null)
{
return;
}
foreach (IDatasetElement element in await _dataset.Elements())
{
if (element.Class is IFeatureClass)
{
if (element.Class.Name.Contains("@"))
{
continue;
}
cmbRefFeatureClass.Items.Add(new FeatureClassItem((IFeatureClass)element.Class));
}
}
AccessFDB fdb = _dataset.Database as AccessFDB;
if (fdb != null)
{
foreach (string view in await fdb.DatabaseViews())
{
IFields fields = fdb.TableFields(view);
if (fields == null ||
fields.FindField("FDB_OID") == null ||
fields.FindField("FDB_SHAPE") == null ||
fields.FindField("FDB_NID") == null)
{
continue;
}
cmbDatabaseViews.Items.Add(view);
}
}
}
async private Task InvokeSetExplorerObject()
{
_exObjectInvokeRequired = false;
mapView1.CancelDrawing(DrawPhase.All);
foreach (IDatasetElement element in _map.MapElements)
{
_map.RemoveLayer(element as ILayer);
}
if (_exObject != null)
{
var instance = await _exObject.GetInstanceAsync();
if (instance is IFeatureClass && ((IFeatureClass)instance).Envelope != null)
{
mapView1.Map = _map;
_map.AddLayer(LayerFactory.Create(instance as IClass));
_map.Display.Limit = ((IFeatureClass)instance).Envelope;
_map.Display.ZoomTo(((IFeatureClass)instance).Envelope);
}
else if (instance is IRasterClass && ((IRasterClass)instance).Polygon != null)
{
mapView1.Map = _map;
_map.AddLayer(LayerFactory.Create(instance as IClass));
_map.Display.Limit = ((IRasterClass)instance).Polygon.Envelope;
_map.Display.ZoomTo(((IRasterClass)instance).Polygon.Envelope);
}
else if (instance is IWebServiceClass && ((IWebServiceClass)instance).Envelope != null)
{
mapView1.Map = _map;
_map.AddLayer(LayerFactory.Create(instance as IClass));
_map.Display.Limit = ((IWebServiceClass)instance).Envelope;
_map.Display.ZoomTo(((IWebServiceClass)instance).Envelope);
}
else if (instance is IFeatureDataset)
{
mapView1.Map = _map;
IFeatureDataset dataset = (IFeatureDataset)instance;
foreach (IDatasetElement element in await dataset.Elements())
{
ILayer layer = LayerFactory.Create(element.Class) as ILayer;
if (layer == null)
{
continue;
}
_map.AddLayer(layer);
}
_map.Display.Limit = await dataset.Envelope();
_map.Display.ZoomTo(await dataset.Envelope());
}
else if (instance is Map)
{
Map map = (Map)instance;
map.NewBitmap -= InvokeNewBitmapCreated;
map.DoRefreshMapView -= InvokeDoRefreshMapView;
map.NewBitmap += InvokeNewBitmapCreated;
map.DoRefreshMapView += InvokeDoRefreshMapView;
mapView1.Map = (Map)instance;
}
}
}
async static Task <int> Main(string[] args)
{
string gmlSource = String.Empty;
string cacheSource = String.Empty;
string cacheTarget = String.Empty;
int jpegQuality = -1, maxlevel = -1;
bool listFilenames = false;
for (int i = 0; i < args.Length; i++)
{
if (args[i] == "-gml")
{
gmlSource = args[++i];
}
if (args[i] == "-cache")
{
cacheSource = args[++i];
}
else if (args[i] == "-target")
{
cacheTarget = args[++i];
}
else if (args[i] == "-jpeg-qual")
{
jpegQuality = int.Parse(args[++i]);
}
else if (args[i] == "-maxlevel")
{
maxlevel = int.Parse(args[++i]);
}
else if (args[i] == "-listfilenames")
{
PlugInManager.InitSilent = true;
listFilenames = true;
}
}
if (String.IsNullOrWhiteSpace(gmlSource) || String.IsNullOrWhiteSpace(cacheSource) || String.IsNullOrWhiteSpace(cacheTarget))
{
Console.WriteLine("USAGE:");
Console.WriteLine("gView.Cmd.ClipCompactTilecache.exe -gml <Filename> -cache <cachedirectory> -target <cachetarget>");
Console.WriteLine(" [-jpeg-qual <quality 0..100>] -maxlevel <level>");
Console.WriteLine(" [-listfilenames]");
return(1);
}
PlugInManager compMan = new PlugInManager();
IFeatureDataset gmlDataset = compMan.CreateInstance(new Guid("dbabe7f1-fe46-4731-ab2b-8a324c60554e")) as IFeatureDataset;
if (gmlDataset == null)
{
Console.WriteLine("GML Dataset-plugin is not supported");
return(1);
}
await gmlDataset.SetConnectionString(gmlSource);
await gmlDataset.Open();
List <IPolygon> sourcePolygons = new List <IPolygon>();
foreach (var element in await gmlDataset.Elements())
{
if (element.Class is IFeatureClass)
{
var fc = (IFeatureClass)element.Class;
using (var cursor = await fc.GetFeatures(null))
{
IFeature feature;
while ((feature = await cursor.NextFeature()) != null)
{
if (feature.Shape is IPolygon)
{
sourcePolygons.Add((IPolygon)feature.Shape);
}
}
}
}
}
if (!listFilenames)
{
Console.WriteLine(sourcePolygons.Count + " polygons found for clipping...");
}
FileInfo configFile = new FileInfo(cacheSource + @"\conf.json");
if (!configFile.Exists)
{
throw new ArgumentException("File " + configFile.FullName + " not exists");
}
#region Image Encoding Parameters
System.Drawing.Imaging.ImageCodecInfo jpgEncoder = GetEncoder(System.Drawing.Imaging.ImageFormat.Jpeg);
// Create an Encoder object based on the GUID
// for the Quality parameter category.
System.Drawing.Imaging.Encoder myEncoder =
System.Drawing.Imaging.Encoder.Quality;
// Create an EncoderParameters object.
// An EncoderParameters object has an array of EncoderParameter
// objects. In this case, there is only one
// EncoderParameter object in the array.
System.Drawing.Imaging.EncoderParameters myEncoderParameters = new System.Drawing.Imaging.EncoderParameters(1);
#endregion
CompactTileConfig cacheConfig = JsonConvert.DeserializeObject <CompactTileConfig>(File.ReadAllText(configFile.FullName));
double dpm = cacheConfig.Dpi / 0.0254;
foreach (var level in cacheConfig.Levels)
{
if (!listFilenames)
{
Console.WriteLine("Level: " + level.Level + " Scale=" + level.Scale);
}
double resolution = (level.Scale / dpm);
double tileWorldWidth = cacheConfig.TileSize[0] * resolution;
double tileWorldHeight = cacheConfig.TileSize[1] * resolution;
var scaleDirectory = new DirectoryInfo(cacheSource + @"\" + ((int)level.Scale).ToString());
if (!scaleDirectory.Exists)
{
continue;
}
foreach (var bundleFile in scaleDirectory.GetFiles("*.tilebundle"))
{
var bundle = new Bundle(bundleFile.FullName);
if (!bundle.Index.Exists)
{
continue;
}
int startRow = bundle.StartRow, startCol = bundle.StartCol;
double bundleWorldWidth = tileWorldWidth * 128D, bundleWorldHeight = tileWorldHeight * 128D;
IPoint bundleLowerLeft = new Point(cacheConfig.Origin[0] + startCol * tileWorldWidth,
cacheConfig.Origin[1] - startRow * tileWorldHeight - bundleWorldHeight);
IEnvelope bundleEnvelope = new Envelope(bundleLowerLeft, new Point(bundleLowerLeft.X + bundleWorldWidth, bundleLowerLeft.Y + bundleWorldHeight));
if (!Intersect(bundleEnvelope, sourcePolygons))
{
continue;
}
if (listFilenames)
{
Console.WriteLine(bundleFile.FullName);
continue;
}
Console.WriteLine("Clip bundle: " + bundleFile.FullName);
var clippedBundleFile = new FileInfo(cacheTarget + "/" + (int)level.Scale + "/" + bundleFile.Name);
if (!clippedBundleFile.Directory.Exists)
{
clippedBundleFile.Directory.Create();
}
if (clippedBundleFile.Exists)
{
clippedBundleFile.Delete();
}
var indexBuilder = new CompactTilesIndexBuilder();
int clippedTilePos = 0;
for (int r = 0; r < 128; r++)
{
for (int c = 0; c < 128; c++)
{
int tileLength;
int tilePos = bundle.Index.TilePosition(r, c, out tileLength);
if (tilePos >= 0 && tileLength >= 0)
{
IPoint tileLowerLeft = new Point(cacheConfig.Origin[0] + (startCol + c) * tileWorldWidth,
cacheConfig.Origin[1] - (startRow + r + 1) * tileWorldHeight);
IEnvelope tileEnvelope = new Envelope(tileLowerLeft, new Point(tileLowerLeft.X + tileWorldWidth, tileLowerLeft.Y + tileWorldHeight));
if (!Intersect(tileEnvelope, sourcePolygons))
{
continue;
}
Console.WriteLine("Append tile " + level.Level + "/" + (startRow + r) + "/" + (startCol + c));
byte[] data = bundle.ImageData(tilePos, tileLength);
if (jpegQuality > 0)
{
#region New Jpeg Quality
MemoryStream ms = new MemoryStream(data);
using (System.Drawing.Image image = System.Drawing.Image.FromStream(ms))
{
MemoryStream outputMs = new MemoryStream();
System.Drawing.Imaging.EncoderParameter myEncoderParameter = new System.Drawing.Imaging.EncoderParameter(myEncoder, Convert.ToInt64(jpegQuality));
myEncoderParameters.Param[0] = myEncoderParameter;
image.Save(outputMs, jpgEncoder, myEncoderParameters);
data = outputMs.ToArray();
}
#endregion
}
using (var stream = new FileStream(clippedBundleFile.FullName, FileMode.Append))
{
stream.Write(data, 0, data.Length);
}
indexBuilder.SetValue(r, c, clippedTilePos, data.Length);
clippedTilePos += data.Length;
}
}
}
if (clippedTilePos > 0)
{
indexBuilder.Save(clippedBundleFile.Directory.FullName + @"\" + new FileInfo(bundle.Index.Filename).Name);
}
}
if (maxlevel >= 0 && level.Level >= maxlevel)
{
break;
}
}
return(0);
}
