async public Task LoadAsync(IDisplay display)
{
double displayResolution = display.mapScale / (/*display.dpi*/ 96.0 / 0.0254);
int level = _grid.GetBestLevel(displayResolution, 90D);
IEnvelope dispEnvelope = display.DisplayTransformation.TransformedBounds(display);
if (display.GeometricTransformer != null)
{
dispEnvelope = (IEnvelope)((IGeometry)display.GeometricTransformer.InvTransform2D(dispEnvelope)).Envelope;
}
dispEnvelope = GeometricTransformerFactory.Transform2D(dispEnvelope, _dataset.SpatialReference, _dataset.WebMercatorSpatialReference)?.Envelope;
double res = _grid.GetLevelResolution(level);
int col0 = _grid.TileColumn(dispEnvelope.minx, res);
int row0 = _grid.TileRow(dispEnvelope.maxy, res);
int col1 = _grid.TileColumn(dispEnvelope.maxx, res);
int row1 = _grid.TileRow(dispEnvelope.miny, res);
int col_from = Math.Max(0, Math.Min(col0, col1)), col_to = Math.Min((int)Math.Round(_grid.Extent.Width / (_grid.TileSizeX * res), 0) - 1, Math.Max(col0, col1));
int row_from = Math.Max(0, Math.Min(row0, row1)), row_to = Math.Min((int)Math.Round(_grid.Extent.Height / (_grid.TileSizeY * res), 0) - 1, Math.Max(row0, row1));
await LoadAsync(level, col_from, col_to, row_from, row_to);
}
void zoom2max_Click(object sender, EventArgs e)
{
if (_doc == null || _doc.FocusMap == null || _doc.FocusMap.Display == null ||
_ovmap == null || _ovmap.Display == null)
{
return;
}
IEnvelope extent = _doc.FocusMap.Display.Limit;
if (_doc.FocusMap.Display.SpatialReference != null &&
!_doc.FocusMap.Display.SpatialReference.Equals(_ovmap.Display.SpatialReference))
{
extent = GeometricTransformerFactory.Transform2D(
extent,
_doc.FocusMap.Display.SpatialReference,
_ovmap.Display.SpatialReference).Envelope;
}
_ovmap.Display.ZoomTo(extent);
if (RefreshOverviewMap != null)
{
RefreshOverviewMap();
}
}
public IPoint GetPoint(ISpatialReference sRef)
{
return(GeometricTransformerFactory.Transform2D(
coordControl1.Point,
coordControl1.SpatialReference,
sRef) as IPoint);
}
private IEnvelope ClassEnvelope(IClass Class, ISpatialReference sRef)
{
IEnvelope envelope = null;
ISpatialReference classSRef = null;
if (Class is IFeatureClass)
{
envelope = ((IFeatureClass)Class).Envelope;
classSRef = ((IFeatureClass)Class).SpatialReference;
}
else if (Class is IRasterClass && ((IRasterClass)Class).Polygon != null)
{
envelope = ((IRasterClass)Class).Polygon.Envelope;
classSRef = ((IRasterClass)Class).SpatialReference;
}
if (envelope != null && classSRef != null && sRef != null && !sRef.Equals(classSRef))
{
IGeometry geom = GeometricTransformerFactory.Transform2D(envelope, classSRef, sRef);
if (geom == null)
{
return(null);
}
envelope = geom.Envelope;
}
return(envelope);
}
public Task <bool> OnEvent(object MapEvent)
{
if (_doc == null || _doc.FocusMap == null || _doc.FocusMap.Display == null)
{
return(Task.FromResult(true));
}
if (!(MapEvent is MapEventRubberband))
{
return(Task.FromResult(true));
}
MapEventRubberband ev = (MapEventRubberband)MapEvent;
if (ev.Map == null)
{
return(Task.FromResult(true));
}
if (!(ev.Map.Display is Display))
{
return(Task.FromResult(true));
}
Display nav = (Display)ev.Map.Display;
IEnvelope extent = new Envelope(ev.minX, ev.minY, ev.maxX, ev.maxY);
if (ev.Map.Display.SpatialReference != null &&
!ev.Map.Display.SpatialReference.Equals(_doc.FocusMap.Display.SpatialReference))
{
extent = GeometricTransformerFactory.Transform2D(
extent,
ev.Map.Display.SpatialReference,
_doc.FocusMap.Display.SpatialReference).Envelope;
}
if (Math.Abs(ev.maxX - ev.minX) < 1e-5 ||
Math.Abs(ev.maxY - ev.minY) < 1e-5)
{
IEnvelope dispEnv = new Envelope(_doc.FocusMap.Display.Envelope);
dispEnv.Center = extent.Center;
_doc.FocusMap.Display.ZoomTo(dispEnv);
}
else
{
_doc.FocusMap.Display.ZoomTo(extent);
}
if (_doc.Application is IMapApplication)
{
((IMapApplication)_doc.Application).RefreshActiveMap(DrawPhase.All);
}
//ev.refreshMap = true;
//ev.drawPhase = DrawPhase.Graphics;
return(Task.FromResult(true));
}
public float GridQuery(gView.Framework.Carto.IDisplay display, IPoint point, ISpatialReference sRef)
{
float floatNodata = (float)_nodata;
TFWFile tfw = this.WorldFile as TFWFile;
if (tfw == null)
{
return(floatNodata);
}
if (this.SpatialReference != null && sRef != null &&
!sRef.Equals(this.SpatialReference))
{
point = GeometricTransformerFactory.Transform2D(point, sRef, this.SpatialReference) as IPoint;
}
if (point == null)
{
return(floatNodata);
}
// Punkt transformieren -> Bild
vector2[] vecs = new vector2[1];
vecs[0] = new vector2(point.X, point.Y);
if (!tfw.ProjectInv(vecs))
{
return(floatNodata);
}
if (vecs[0].x < 0 || vecs[0].x >= _iWidth ||
vecs[0].y < 0 || vecs[0].y >= _iHeight)
{
return(floatNodata);
}
unsafe
{
fixed(float *buf = new float[2])
{
_gridQueryBand.ReadRaster((int)vecs[0].x, (int)vecs[0].y, 1, 1,
(IntPtr)buf,
1, 1, OSGeo_v1.GDAL.DataType.GDT_CFloat32, 4, 0);
if ((_hasNoDataVal != 0 && buf[0] == floatNodata) ||
(_useIgnoreValue && buf[0] == _ignoreValue))
{
return(floatNodata);
}
return(buf[0]);
}
}
}
async public Task <bool> PerformUpdateFeature(IFeatureClass fc, IFeature feature)
{
if (fc == null || feature == null ||
fc.Dataset == null ||
!(fc.Dataset.Database is IFeatureUpdater))
{
return(false);
}
if (_attributEditor != null && !_attributEditor.CommitValues())
{
MessageBox.Show(_attributEditor.LastErrorMessage, "ERROR: Commit Values...");
return(false);
}
EditorEventArgument args = new EditorEventArgument(fc, feature);
if (OnUpdateFeature != null)
{
OnUpdateFeature(this, args);
}
if (args.Cancel)
{
_lastMsg = args.Message;
return(false);
}
IGeometry shape = feature.Shape;
if (_doc != null &&
_doc.FocusMap != null &&
_doc.FocusMap.Display != null &&
_doc.FocusMap.Display.SpatialReference != null &&
!_doc.FocusMap.Display.SpatialReference.Equals(_fc.SpatialReference))
{
feature.Shape = GeometricTransformerFactory.Transform2D(
feature.Shape,
_doc.FocusMap.Display.SpatialReference,
_fc.SpatialReference);
}
bool ret = await((IFeatureUpdater)fc.Dataset.Database).Update(fc, feature);
feature.Shape = shape;
if (!ret)
{
_lastMsg = fc.Dataset.Database.LastErrorMessage;
}
return(ret);
}
private IEnvelope ProjectEnvelope(IEnvelope env, ISpatialReference sRef)
{
if (sRef == null || env == null || _sRef == null)
{
return(env);
}
IGeometry geom = GeometricTransformerFactory.Transform2D(env, sRef, _sRef);
if (geom != null)
{
return(geom.Envelope);
}
return(null);
}
public Task <ICursor> PointQuery(gView.Framework.Carto.IDisplay display, IPoint point, ISpatialReference sRef, IUserData userdata)
{
TFWFile tfw = this.WorldFile as TFWFile;
if (tfw == null)
{
return(Task.FromResult <ICursor>(null));
}
if (this.SpatialReference != null && sRef != null &&
!sRef.Equals(this.SpatialReference))
{
point = GeometricTransformerFactory.Transform2D(point, sRef, this.SpatialReference) as IPoint;
}
if (point == null)
{
return(Task.FromResult <ICursor>(null));;
}
// Punkt transformieren -> Bild
vector2[] vecs = new vector2[1];
vecs[0] = new vector2(point.X, point.Y);
if (!tfw.ProjectInv(vecs))
{
return(Task.FromResult <ICursor>(null));;
}
if (vecs[0].x < 0 || vecs[0].x >= _iWidth ||
vecs[0].y < 0 || vecs[0].y >= _iHeight)
{
return(Task.FromResult <ICursor>(null));
}
switch (_type)
{
case RasterType.image:
return(Task.FromResult <ICursor>(QueryImage((int)Math.Floor(vecs[0].x), (int)Math.Floor(vecs[0].y))));
case RasterType.grid:
return(Task.FromResult <ICursor>(QueryGrid((int)Math.Floor(vecs[0].x), (int)Math.Floor(vecs[0].y))));
}
return(Task.FromResult <ICursor>(null));;
}
static public void GeometryToSpatialReference(this IQueryFilter filter, ISpatialReference targetSRef)
{
if (targetSRef != null &&
filter is ISpatialFilter &&
((ISpatialFilter)filter).Geometry != null &&
((ISpatialFilter)filter).FilterSpatialReference != null &&
!targetSRef.Equals(((ISpatialFilter)filter).FilterSpatialReference))
{
var spatialFilter = (ISpatialFilter)filter;
spatialFilter.Geometry =
GeometricTransformerFactory.Transform2D(
spatialFilter.Geometry,
spatialFilter.FilterSpatialReference,
targetSRef);
spatialFilter.FilterSpatialReference = targetSRef;
}
}
public bool ProjectTo(ISpatialReference sRef)
{
if (_bounds == null)
{
return(false);
}
if (_sRef != null && !_sRef.Equals(sRef))
{
IGeometry result = GeometricTransformerFactory.Transform2D(_bounds, _sRef, sRef);
if (result != null && result.Envelope != null)
{
_bounds = result.Envelope;
_sRef = sRef;
return(true);
}
}
return(true);
}
public IEnvelope Envelope(string srs)
{
IEnvelope env = null;
_boundaryBoxes.TryGetValue(srs.ToUpper(), out env);
if (env == null && LatLonBoundingBox != null)
{
// Projezieren
ISpatialReference sRef = gView.Framework.Geometry.SpatialReference.FromID(srs);
ISpatialReference epsg_4326 = gView.Framework.Geometry.SpatialReference.FromID("epsg:4326");
IGeometry geom = GeometricTransformerFactory.Transform2D(LatLonBoundingBox, epsg_4326, sRef);
if (geom != null)
{
env = geom.Envelope;
}
}
return((env != null) ? env : new Envelope(-180, -90, 180, 90));
}
async public Task <IFeatureCursor> GetFeatures(IQueryFilter filter)
{
if (filter is ISpatialFilter)
{
if (this.SpatialReference != null &&
((ISpatialFilter)filter).FilterSpatialReference != null &&
!((ISpatialFilter)filter).FilterSpatialReference.Equals(this.SpatialReference))
{
filter = (ISpatialFilter)filter.Clone();
((ISpatialFilter)filter).Geometry =
GeometricTransformerFactory.Transform2D(((ISpatialFilter)filter).Geometry,
((ISpatialFilter)filter).FilterSpatialReference,
this.SpatialReference);
((ISpatialFilter)filter).FilterSpatialReference = null;
}
}
if (_dataset.Source != null)
{
if (_dataset.Source.IsValid)
{
if (filter is DistinctFilter)
{
return(new GeoJsonDistinctFeatureCursor(await _dataset.Source?.GetFeatures(this.GeometryType), (DistinctFilter)filter));
}
return(new GeoJsonFeatureCursor(this, await _dataset.Source?.GetFeatures(this.GeometryType), filter));
}
else if (_dataset.Source.LastException != null)
{
throw new Exception(_dataset.Source.LastException.AllMessages());
}
}
// Dataset is not intializalized
return(new GeoJsonFeatureCursor(this, new IFeature[0], filter));
}
private void InsertMapExtent(IDisplay display)
{
if (_ovmap == null || display == null ||
_ovmap.Display == null)
{
return;
}
IGeometry mapEnv = display.Envelope;
_ovmap.Display.GraphicsContainer.Elements.Clear();
if (display.SpatialReference != null &&
!display.SpatialReference.Equals(_ovmap.Display.SpatialReference))
{
mapEnv = GeometricTransformerFactory.Transform2D(
mapEnv, display.SpatialReference,
_ovmap.Display.SpatialReference);
}
_envGraphics.LimitEnvelope = _ovmap.Display.Envelope;
_envGraphics.Geometry = mapEnv;
_ovmap.Display.GraphicsContainer.Elements.Add(_envGraphics);
}
public IGeometry Transform(IGeometry geometry, ISpatialReference geometrySpatialReference)
{
if (geometry == null)
{
return(null);
}
if (geometrySpatialReference == null || _spatialReference == null || geometrySpatialReference.Equals(_spatialReference))
{
return(geometry);
}
IGeometricTransformer transformer = GeometricTransformerFactory.Create();
//transformer.FromSpatialReference = geometrySpatialReference;
//transformer.ToSpatialReference = _spatialReference;
transformer.SetSpatialReferences(geometrySpatialReference, _spatialReference);
IGeometry geom = transformer.Transform2D(geometry) as IGeometry;
transformer.Release();
return(geom);
}
private void treeObjects_MouseClick(object sender, MouseEventArgs e)
{
if (_doc == null)
{
return;
}
if (_doc.FocusMap == null)
{
return;
}
if (_doc.FocusMap.Display == null)
{
return;
}
if (_doc.Application == null)
{
return;
}
TreeNode node = treeObjects.GetNodeAt(e.X, e.Y);
if (node is FeatureTreeNode && e.Button == MouseButtons.Left)
{
IFeature feature = ((FeatureTreeNode)node).Feature;
ISpatialReference sRef = ((FeatureTreeNode)node).SpatialReference;
ILayer layer = ((FeatureTreeNode)node).Layer;
if (feature != null && feature.Shape != null)
{
if (e.X > 50)
{
IGeometry shape = feature.Shape;
if (sRef != null && !sRef.Equals(_doc.FocusMap.Display.SpatialReference))
{
shape = GeometricTransformerFactory.Transform2D(shape, sRef, _doc.FocusMap.Display.SpatialReference);
}
_doc.FocusMap.HighlightGeometry(shape, 300);
}
else if (e.X >= 38)
{
IEnvelope envelope = feature.Shape.Envelope;
if (sRef != null && !sRef.Equals(_doc.FocusMap.Display.SpatialReference))
{
IGeometry geom = GeometricTransformerFactory.Transform2D(envelope,
sRef,
_doc.FocusMap.Display.SpatialReference);
if (geom == null)
{
return;
}
envelope = geom.Envelope;
}
_doc.FocusMap.Display.ZoomTo(envelope);
if (layer != null && layer.MaximumZoomToFeatureScale > _doc.FocusMap.Display.mapScale)
{
_doc.FocusMap.Display.mapScale = layer.MaximumZoomToFeatureScale;
}
if (_doc.Application is IMapApplication)
{
((IMapApplication)_doc.Application).RefreshActiveMap(DrawPhase.All);
}
}
}
}
//else if(node is CategoryTreeNode)
//{
// var categoryTreeNode = (CategoryTreeNode)node;
// MessageBox.Show(categoryTreeNode.Category);
//}
}
async public Task <bool> ImportToNewFeatureclass(IFeatureDatabase fdb, string dsname, string fcname, IFeatureClass sourceFC, FieldTranslation fieldTranslation, bool project, List <IQueryFilter> filters, ISpatialIndexDef sIndexDef, geometryType?sourceGeometryType = null)
{
if (!_cancelTracker.Continue)
{
return(true);
}
if (fdb is AccessFDB)
{
ISpatialIndexDef dsSpatialIndexDef = await((AccessFDB)fdb).SpatialIndexDef(dsname);
if (sIndexDef == null)
{
sIndexDef = dsSpatialIndexDef;
}
else if (sIndexDef.GeometryType != dsSpatialIndexDef.GeometryType)
{
_errMsg = "Spatial-Index-Definition-GeometryTypes are not compatible!";
return(false);
}
}
if (sIndexDef == null)
{
sIndexDef = new gViewSpatialIndexDef();
}
bool msSpatial = false;
if (fdb is SqlFDB &&
(sIndexDef.GeometryType == GeometryFieldType.MsGeography ||
sIndexDef.GeometryType == GeometryFieldType.MsGeometry))
{
msSpatial = true;
}
else
{
int maxAllowedLevel = ((fdb is SqlFDB || fdb is pgFDB) ? 62 : 30);
if (sIndexDef.Levels > maxAllowedLevel)
{
ISpatialReference defSRef = sIndexDef.SpatialReference;
sIndexDef = new gViewSpatialIndexDef(
sIndexDef.SpatialIndexBounds,
Math.Min(sIndexDef.Levels, maxAllowedLevel),
sIndexDef.MaxPerNode,
sIndexDef.SplitRatio);
((gViewSpatialIndexDef)sIndexDef).SpatialReference = defSRef;
}
}
try
{
fcname = fcname.Replace(".", "_");
IFeatureDataset destDS = await fdb.GetDataset(dsname);
if (destDS == null)
{
_errMsg = fdb.LastErrorMessage;
return(false);
}
IDatasetElement destLayer = await destDS.Element(fcname);
if (destLayer != null)
{
if (ReportRequest != null)
{
RequestArgs args = new RequestArgs(
"Featureclass " + fcname + " already exists in " + dsname + "\nDo want to replace it?",
MessageBoxButtons.YesNoCancel,
DialogResult.Cancel);
ReportRequest(this, args);
switch (args.Result)
{
case DialogResult.No:
return(true);
case DialogResult.Cancel:
_errMsg = "Import is canceled by the user...";
return(false);
}
}
}
GeometryDef geomDef = new GeometryDef(sourceFC);
if (geomDef.GeometryType == geometryType.Unknown && sourceGeometryType != null)
{
geomDef.GeometryType = sourceGeometryType.Value;
}
int fcID = -1;
if (destLayer != null)
{
if (fdb is AccessFDB)
{
fcID = await((AccessFDB)fdb).ReplaceFeatureClass(destDS.DatasetName,
fcname,
geomDef,
(fieldTranslation == null) ?
((sourceFC.Fields != null) ? (IFields)sourceFC.Fields.Clone() : new Fields()) :
fieldTranslation.DestinationFields);
if (fcID < 0)
{
_errMsg = "Can't replace featureclass " + fcname + "...\r\n" + fdb.LastErrorMessage;
destDS.Dispose();
return(false);
}
}
else
{
await fdb.DeleteFeatureClass(fcname);
}
}
if (fcID < 0)
{
fcID = await fdb.CreateFeatureClass(destDS.DatasetName,
fcname,
geomDef,
(fieldTranslation == null)?
((sourceFC.Fields != null) ? (IFields)sourceFC.Fields.Clone() : new Fields()) :
fieldTranslation.DestinationFields);
}
if (fcID < 0)
{
_errMsg = "Can't create featureclass " + fcname + "...\r\n" + fdb.LastErrorMessage;
destDS.Dispose();
return(false);
}
destLayer = await destDS.Element(fcname);
if (destLayer == null || !(destLayer.Class is IFeatureClass))
{
_errMsg = "Can't load featureclass " + fcname + "...\r\n" + destDS.LastErrorMessage;
destDS.Dispose();
return(false);
}
IFeatureClass destFC = destLayer.Class as IFeatureClass;
if (project && destFC.SpatialReference != null && !destFC.SpatialReference.Equals(sourceFC.SpatialReference))
{
_transformer = GeometricTransformerFactory.Create();
//_transformer.FromSpatialReference = sourceFC.SpatialReference;
//_transformer.ToSpatialReference = destFC.SpatialReference;
_transformer.SetSpatialReferences(sourceFC.SpatialReference, destFC.SpatialReference);
}
if (!Envelope.IsNull(sIndexDef.SpatialIndexBounds) &&
sIndexDef.SpatialReference != null && !sIndexDef.SpatialReference.Equals(destFC.SpatialReference))
{
if (!sIndexDef.ProjectTo(destFC.SpatialReference))
{
_errMsg = "Can't project SpatialIndex Boundaries...";
destDS.Dispose();
return(false);
}
}
DualTree tree = null;
BinaryTree2Builder tree2 = null;
if (msSpatial)
{
((SqlFDB)fdb).SetMSSpatialIndex((MSSpatialIndex)sIndexDef, destFC.Name);
await((SqlFDB)fdb).SetFeatureclassExtent(destFC.Name, sIndexDef.SpatialIndexBounds);
}
else
{
if (_treeVersion == TreeVersion.BinaryTree)
{
tree = await SpatialIndex(sourceFC, sIndexDef.MaxPerNode, filters);
if (tree == null)
{
return(false);
}
}
else if (_treeVersion == TreeVersion.BinaryTree2)
{
if (_schemaOnly && sourceFC.Dataset.Database is IImplementsBinarayTreeDef)
{
BinaryTreeDef tDef = await((IImplementsBinarayTreeDef)sourceFC.Dataset.Database).BinaryTreeDef(sourceFC.Name);
tree2 = new BinaryTree2Builder(tDef.Bounds, tDef.MaxLevel, tDef.MaxPerNode, tDef.SplitRatio);
}
else
{
tree2 = await SpatialIndex2(fdb, sourceFC, sIndexDef, filters);
if (tree2 == null)
{
return(false);
}
}
}
// Vorab einmal alle "Bounds" festlegen, damit auch
// ein aufzubauender Layer geviewt werden kann
if (_treeVersion == TreeVersion.BinaryTree2 && fdb is AccessFDB)
{
if (ReportAction != null)
{
ReportAction(this, "Insert spatial index nodes");
}
List <long> nids = new List <long>();
foreach (BinaryTree2BuilderNode node in tree2.Nodes)
{
nids.Add(node.Number);
}
await((AccessFDB)fdb).ShrinkSpatialIndex(fcname, nids);
if (ReportAction != null)
{
ReportAction(this, "Set spatial index bounds");
}
//((AccessFDB)fdb).SetSpatialIndexBounds(fcname, "BinaryTree2", tree2.Bounds, sIndexDef.SplitRatio, sIndexDef.MaxPerNode, tree2.maxLevels);
await((AccessFDB)fdb).SetSpatialIndexBounds(fcname, "BinaryTree2", tree2.Bounds, tree2.SplitRatio, tree2.MaxPerNode, tree2.maxLevels);
await((AccessFDB)fdb).SetFeatureclassExtent(fcname, tree2.Bounds);
}
}
if (_cancelTracker.Continue)
{
bool result = true;
if (!_schemaOnly)
{
if (msSpatial)
{
result = await CopyFeatures(sourceFC, fdb, destFC, fieldTranslation, filters);
}
else if (_treeVersion == TreeVersion.BinaryTree)
{
if (String.IsNullOrEmpty(sourceFC.IDFieldName)) // SDE Views haben keine ID -> Tree enthält keine Features
{
result = await CopyFeatures(sourceFC, fdb, destFC, fieldTranslation, filters);
}
else
{
result = await CopyFeatures(sourceFC, fdb, destFC, fieldTranslation, tree);
}
}
else if (_treeVersion == TreeVersion.BinaryTree2)
{
if (String.IsNullOrEmpty(sourceFC.IDFieldName)) // SDE Views haben keine ID -> Tree enthält keine Features
{
result = await CopyFeatures(sourceFC, fdb, destFC, fieldTranslation, filters);
}
else
{
result = await CopyFeatures2(sourceFC, fdb, destFC, fieldTranslation, tree2);
}
}
if (!result)
{
await fdb.DeleteFeatureClass(fcname);
destDS.Dispose();
return(false);
}
}
}
destDS.Dispose();
if (_cancelTracker.Continue && fdb is AccessFDB)
{
if (ReportAction != null)
{
ReportAction(this, "Calculate extent");
}
await((AccessFDB)fdb).CalculateExtent(destFC);
if (msSpatial == false)
{
if (_treeVersion == TreeVersion.BinaryTree)
{
if (ReportAction != null)
{
ReportAction(this, "Set spatial index bounds");
}
await((AccessFDB)fdb).SetSpatialIndexBounds(fcname, "BinaryTree", tree.Bounds, sIndexDef.SplitRatio, sIndexDef.MaxPerNode, 0);
if (ReportAction != null)
{
ReportAction(this, "Insert spatial index nodes");
}
await((AccessFDB)fdb).__intInsertSpatialIndexNodes2(fcname, tree.Nodes);
}
}
return(true);
}
else
{
await fdb.DeleteFeatureClass(fcname);
_errMsg = "Import is canceled by the user...";
return(false);
}
}
finally
{
if (_transformer != null)
{
_transformer.Release();
_transformer = null;
}
}
}
public Task <bool> OnEvent(object element, object dataset)
{
if (_doc == null || _doc.FocusMap == null || _doc.FocusMap.Display == null)
{
return(Task.FromResult(true));
}
if (element is IFeatureLayer && ((IFeatureLayer)element).FeatureClass != null && ((IFeatureLayer)element).FeatureClass.Envelope != null)
{
IEnvelope envelope = ((IFeatureLayer)element).FeatureClass.Envelope;
if (((IFeatureLayer)element).FeatureClass.SpatialReference != null && !((IFeatureLayer)element).FeatureClass.SpatialReference.Equals(_doc.FocusMap.Display.SpatialReference))
{
IGeometry geom = GeometricTransformerFactory.Transform2D(envelope, ((IFeatureLayer)element).FeatureClass.SpatialReference, _doc.FocusMap.Display.SpatialReference);
if (geom == null)
{
return(Task.FromResult(true));
}
envelope = geom.Envelope;
}
_doc.FocusMap.Display.ZoomTo(envelope);
}
else if (element is IRasterLayer && ((IRasterLayer)element).RasterClass != null && ((IRasterLayer)element).RasterClass.Polygon != null)
{
IEnvelope envelope = ((IRasterLayer)element).RasterClass.Polygon.Envelope;
if (((IRasterLayer)element).RasterClass.SpatialReference != null && !((IRasterLayer)element).RasterClass.SpatialReference.Equals(_doc.FocusMap.Display.SpatialReference))
{
IGeometry geom = GeometricTransformerFactory.Transform2D(envelope, ((IRasterLayer)element).RasterClass.SpatialReference, _doc.FocusMap.Display.SpatialReference);
if (geom == null)
{
return(Task.FromResult(true));
}
envelope = geom.Envelope;
}
_doc.FocusMap.Display.ZoomTo(envelope);
}
else if (element is IWebServiceLayer && ((IWebServiceLayer)element).WebServiceClass != null && ((IWebServiceLayer)element).WebServiceClass.Envelope != null)
{
IEnvelope envelope = ((IWebServiceLayer)element).WebServiceClass.Envelope;
if (((IWebServiceLayer)element).WebServiceClass.SpatialReference != null && !((IWebServiceLayer)element).WebServiceClass.SpatialReference.Equals(_doc.FocusMap.Display.SpatialReference))
{
IGeometry geom = GeometricTransformerFactory.Transform2D(envelope, ((IWebServiceLayer)element).WebServiceClass.SpatialReference, _doc.FocusMap.Display.SpatialReference);
if (geom == null)
{
return(Task.FromResult(true));
}
envelope = geom.Envelope;
}
_doc.FocusMap.Display.ZoomTo(envelope);
}
else
{
return(Task.FromResult(true));
}
if (_doc.Application is IMapApplication)
{
((IMapApplication)_doc.Application).RefreshActiveMap(DrawPhase.All);
}
return(Task.FromResult(true));
}
async override public Task <bool> RefreshMap(DrawPhase phase, ICancelTracker cancelTracker)
{
base.ResetRequestExceptions();
bool printerMap = (this.GetType() == typeof(PrinterMap));
try
{
_original.FireStartRefreshMap();
using (var datasetCachingContext = new DatasetCachingContext(this))
{
this.IsRefreshing = true;
_lastException = null;
if (_canvas != null && phase == DrawPhase.Graphics)
{
return(true);
}
#region Start Drawing/Initialisierung
this.ZoomTo(m_actMinX, m_actMinY, m_actMaxX, m_actMaxY);
if (cancelTracker == null)
{
cancelTracker = new CancelTracker();
}
IGeometricTransformer geoTransformer = GeometricTransformerFactory.Create();
//geoTransformer.ToSpatialReference = this.SpatialReference;
if (!printerMap)
{
if (phase == DrawPhase.All)
{
DisposeStreams();
}
if (_bitmap != null && (_bitmap.Width != iWidth || _bitmap.Height != iHeight))
{
if (!DisposeImage())
{
return(false);
}
}
if (_bitmap == null)
{
//DisposeStreams();
_bitmap = GraphicsEngine.Current.Engine.CreateBitmap(iWidth, iHeight, GraphicsEngine.PixelFormat.Rgba32);
//if (NewBitmap != null && cancelTracker.Continue) NewBitmap(_image);
}
_canvas = _bitmap.CreateCanvas();
//this.dpi = /*96f*/ /* _canvas.DpiX*/ GraphicsEngine.Current.Engine.ScreenDpi;
// NewBitmap immer aufrufen, da sonst neuer DataView nix mitbekommt
if (NewBitmap != null && cancelTracker.Continue)
{
NewBitmap?.BeginInvoke(_bitmap, new AsyncCallback(AsyncInvoke.RunAndForget), null);
}
using (var brush = GraphicsEngine.Current.Engine.CreateSolidBrush(_backgroundColor))
{
_canvas.FillRectangle(brush, new GraphicsEngine.CanvasRectangle(0, 0, iWidth, iHeight));
}
}
#endregion
#region Geometry
if (Bit.Has(phase, DrawPhase.Geography))
//if (phase == DrawPhase.All || phase == DrawPhase.Geography)
{
LabelEngine.Init(this.Display, printerMap);
this.GeometricTransformer = geoTransformer;
// Thread für MapServer Datasets starten...
#region WebServiceLayer
List <IWebServiceLayer> webServices;
if (this.TOC != null)
{
webServices = ListOperations <IWebServiceLayer> .Swap(this.TOC.VisibleWebServiceLayers);
}
else
{
webServices = new List <IWebServiceLayer>();
foreach (IDatasetElement layer in this.MapElements)
{
if (!(layer is IWebServiceLayer))
{
continue;
}
if (((ILayer)layer).Visible)
{
webServices.Add((IWebServiceLayer)layer);
}
}
}
int webServiceOrder = 0;
foreach (IWebServiceLayer element in webServices)
{
if (!element.Visible)
{
continue;
}
RenderServiceRequest srt = new RenderServiceRequest(this, element, webServiceOrder++);
srt.finish += new RenderServiceRequest.RequestThreadFinished(MapRequestThread_finished);
//Thread thread = new Thread(new ThreadStart(srt.ImageRequest));
m_imageMerger.max++;
//thread.Start();
var task = srt.ImageRequest(); // start the task...
}
#endregion
#region Layerlisten erstellen
List <ILayer> layers;
if (this.TOC != null)
{
if (this.ToString() == "gView.MapServer.Instance.ServiceMap")
{
layers = ListOperations <ILayer> .Swap(this.TOC.Layers);
}
else
{
layers = ListOperations <ILayer> .Swap(this.TOC.VisibleLayers);
}
}
else
{
layers = new List <ILayer>();
foreach (IDatasetElement layer in this.MapElements)
{
if (!(layer is ILayer))
{
continue;
}
if (((ILayer)layer).Visible)
{
layers.Add((ILayer)layer);
}
}
}
List <IFeatureLayer> labelLayers = this.OrderedLabelLayers(layers);
#endregion
#region Renderer Features
foreach (ILayer layer in layers)
{
if (!cancelTracker.Continue)
{
break;
}
if (!layer.RenderInScale(this))
{
continue;
}
SetGeotransformer(layer, geoTransformer);
DateTime startTime = DateTime.Now;
FeatureCounter fCounter = new FeatureCounter();
if (layer is IFeatureLayer)
{
if (layer.Class?.Dataset is IFeatureCacheDataset)
{
await((IFeatureCacheDataset)layer.Class.Dataset).InitFeatureCache(datasetCachingContext);
}
IFeatureLayer fLayer = (IFeatureLayer)layer;
if (fLayer.FeatureRenderer == null &&
(
fLayer.LabelRenderer == null ||
(fLayer.LabelRenderer != null && fLayer.LabelRenderer.RenderMode != LabelRenderMode.RenderWithFeature)
))
{
//continue;
}
else
{
RenderFeatureLayer rlt = new RenderFeatureLayer(this, datasetCachingContext, fLayer, cancelTracker, fCounter);
if (fLayer.LabelRenderer != null && fLayer.LabelRenderer.RenderMode == LabelRenderMode.RenderWithFeature)
{
rlt.UseLabelRenderer = true;
}
else
{
rlt.UseLabelRenderer = labelLayers.IndexOf(fLayer) == 0; // letzten Layer gleich mitlabeln
}
if (rlt.UseLabelRenderer)
{
labelLayers.Remove(fLayer);
}
if (cancelTracker.Continue)
{
DrawingLayer?.BeginInvoke(layer.Title, new AsyncCallback(AsyncInvoke.RunAndForget), null);
}
await rlt.Render();
}
}
if (layer is IRasterLayer && ((IRasterLayer)layer).RasterClass != null)
{
IRasterLayer rLayer = (IRasterLayer)layer;
if (rLayer.RasterClass.Polygon == null)
{
continue;
}
IEnvelope dispEnvelope = this.DisplayTransformation.TransformedBounds(this); //this.Envelope;
if (Display.GeometricTransformer != null)
{
dispEnvelope = ((IGeometry)Display.GeometricTransformer.InvTransform2D(dispEnvelope)).Envelope;
}
if (gView.Framework.SpatialAlgorithms.Algorithm.IntersectBox(rLayer.RasterClass.Polygon, dispEnvelope))
{
if (rLayer.Class is IParentRasterLayer)
{
if (cancelTracker.Continue)
{
DrawingLayer?.BeginInvoke(layer.Title, new AsyncCallback(AsyncInvoke.RunAndForget), null);
}
await DrawRasterParentLayer((IParentRasterLayer)rLayer.Class, cancelTracker, rLayer);
}
else
{
RenderRasterLayer rlt = new RenderRasterLayer(this, rLayer, rLayer, cancelTracker);
if (cancelTracker.Continue)
{
DrawingLayer?.BeginInvoke(layer.Title, new AsyncCallback(AsyncInvoke.RunAndForget), null);
}
await rlt.Render();
}
}
}
// Andere Layer (zB IRasterLayer)
_original.FireDrawingLayerFinished(new gView.Framework.system.TimeEvent("Drawing: " + layer.Title, startTime, DateTime.Now, fCounter.Counter));
FireRefreshMapView(1000);
}
#endregion
#region Label Features
if (labelLayers.Count != 0)
{
StreamImage(ref _msGeometry, _bitmap);
foreach (IFeatureLayer fLayer in labelLayers)
{
this.SetGeotransformer(fLayer, geoTransformer);
FeatureCounter fCounter = new FeatureCounter();
DateTime startTime = DateTime.Now;
RenderLabel rlt = new RenderLabel(this, fLayer, cancelTracker, fCounter);
if (cancelTracker.Continue)
{
DrawingLayer?.BeginInvoke(fLayer.Title, new AsyncCallback(AsyncInvoke.RunAndForget), null);
}
await rlt.Render();
_original.FireDrawingLayerFinished(new gView.Framework.system.TimeEvent("Labelling: " + fLayer.Title, startTime, DateTime.Now, fCounter.Counter));
}
DrawStream(_canvas, _msGeometry);
}
if (!printerMap)
{
LabelEngine.Draw(this.Display, cancelTracker);
}
LabelEngine.Release();
#endregion
#region Waiting for Webservices
if (cancelTracker.Continue)
{
if (webServices != null && webServices.Count != 0)
{
DrawingLayer?.BeginInvoke("...Waiting for WebServices...", new AsyncCallback(AsyncInvoke.RunAndForget), null);
}
while (m_imageMerger.Count < m_imageMerger.max)
{
await Task.Delay(100);
}
}
if (_drawScaleBar)
{
m_imageMerger.mapScale = this.mapScale;
m_imageMerger.dpi = this.dpi;
}
if (m_imageMerger.Count > 0)
{
var clonedBitmap = _bitmap.Clone(GraphicsEngine.PixelFormat.Rgba32);
clonedBitmap.MakeTransparent(_backgroundColor);
m_imageMerger.Add(new GeorefBitmap(clonedBitmap), 999);
if (!m_imageMerger.Merge(_bitmap, this.Display) &&
(this is IServiceMap) &&
((IServiceMap)this).MapServer != null)
{
await((IServiceMap)this).MapServer.LogAsync(
this.Name,
"Image Merger:",
loggingMethod.error,
m_imageMerger.LastErrorMessage);
}
m_imageMerger.Clear();
}
StreamImage(ref _msGeometry, _bitmap);
#endregion
}
#endregion
#region Draw Selection
if (Bit.Has(phase, DrawPhase.Selection))
{
if (phase != DrawPhase.All)
{
DrawStream(_canvas, _msGeometry);
}
foreach (IDatasetElement layer in this.MapElements)
{
if (!cancelTracker.Continue)
{
break;
}
if (!(layer is ILayer))
{
continue;
}
if (layer is IFeatureLayer &&
layer is IFeatureSelection &&
((IFeatureSelection)layer).SelectionSet != null &&
((IFeatureSelection)layer).SelectionSet.Count > 0)
{
SetGeotransformer((ILayer)layer, geoTransformer);
await RenderSelection(layer as IFeatureLayer, cancelTracker);
} // Andere Layer (zB IRasterLayer)
else if (layer is IWebServiceLayer)
{
IWebServiceLayer wLayer = (IWebServiceLayer)layer;
if (wLayer.WebServiceClass == null)
{
continue;
}
foreach (IWebServiceTheme theme in wLayer.WebServiceClass.Themes)
{
if (theme is IFeatureLayer &&
theme.SelectionRenderer != null &&
theme is IFeatureSelection &&
((IFeatureSelection)theme).SelectionSet != null &&
((IFeatureSelection)theme).SelectionSet.Count > 0)
{
SetGeotransformer(theme, geoTransformer);
await RenderSelection(theme as IFeatureLayer, cancelTracker);
}
}
}
}
StreamImage(ref _msSelection, _bitmap);
}
#endregion
#region Graphics
if (Bit.Has(phase, DrawPhase.Graphics))
//if (phase == DrawPhase.All || phase == DrawPhase.Graphics)
{
if (phase != DrawPhase.All)
{
DrawStream(_canvas, (_msSelection != null) ? _msSelection : _msGeometry);
}
foreach (IGraphicElement grElement in Display.GraphicsContainer.Elements)
{
grElement.Draw(Display);
}
foreach (IGraphicElement grElement in Display.GraphicsContainer.SelectedElements)
{
if (grElement is IGraphicElement2)
{
if (((IGraphicElement2)grElement).Ghost != null)
{
((IGraphicElement2)grElement).Ghost.Draw(Display);
}
((IGraphicElement2)grElement).DrawGrabbers(Display);
}
}
}
#endregion
#region Cleanup
if (geoTransformer != null)
{
this.GeometricTransformer = null;
geoTransformer.Release();
geoTransformer = null;
}
#endregion
#region Send Events
// Überprüfen, ob sich Extent seit dem letztem Zeichnen geändert hat...
if (cancelTracker.Continue)
{
if (_lastRenderExtent == null)
{
_lastRenderExtent = new Envelope();
}
if (NewExtentRendered != null)
{
if (!_lastRenderExtent.Equals(Display.Envelope))
{
NewExtentRendered(this, Display.Envelope);
}
}
_lastRenderExtent.minx = Display.Envelope.minx;
_lastRenderExtent.miny = Display.Envelope.miny;
_lastRenderExtent.maxx = Display.Envelope.maxx;
_lastRenderExtent.maxy = Display.Envelope.maxy;
}
#endregion
return(true);
}
}
catch (Exception ex)
{
_lastException = ex;
AddRequestException(ex);
//System.Windows.Forms.MessageBox.Show(ex.Message+"\n"+ex.InnerException+"\n"+ex.Source);
return(false);
}
finally
{
AppendRequestExceptionsToImage();
if (!printerMap)
{
if (_canvas != null)
{
_canvas.Dispose();
}
_canvas = null;
}
this.IsRefreshing = false;
}
}
async public Task <bool> OnEvent(object MapEvent)
{
if (!(MapEvent is MapEvent))
{
return(false);
}
IMap map = ((MapEvent)MapEvent).Map;
bool firstDataset = (map[0] == null);
List <ExplorerDialogFilter> filters = new List <ExplorerDialogFilter>();
filters.Add(new OpenDataFilter());
ExplorerDialog dlg = new ExplorerDialog("Add data...", filters, true);
if (dlg.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
List <IDataset> datasets = await dlg.Datasets();
FormDatasetProperties datasetProps = await FormDatasetProperties.CreateAsync(null, datasets);
try
{
if (((MapEvent)MapEvent).UserData == null)
{
if (datasetProps.ShowDialog() != System.Windows.Forms.DialogResult.OK)
{
return(true);
}
}
}
catch // Kann ObjectDisposed Exception werfen...
{
return(true);
}
Envelope env = null;
foreach (ILayer layer in datasetProps.Layers)
{
ISpatialReference sRef = null;
IEnvelope classEnv = null;
if (layer is IFeatureLayer && ((IFeatureLayer)layer).FeatureClass != null && ((IFeatureLayer)layer).FeatureClass.Envelope != null)
{
sRef = ((IFeatureLayer)layer).FeatureClass.SpatialReference;
classEnv = ((IFeatureLayer)layer).FeatureClass.Envelope;
}
else if (layer is IRasterLayer && ((IRasterLayer)layer).RasterClass != null && ((IRasterLayer)layer).RasterClass.Polygon != null && ((IRasterLayer)layer).RasterClass.Polygon.Envelope != null)
{
sRef = ((IRasterLayer)layer).RasterClass.SpatialReference;
classEnv = ((IRasterLayer)layer).RasterClass.Polygon.Envelope;
}
else if (layer is IWebServiceLayer && ((IWebServiceLayer)layer).WebServiceClass != null && ((IWebServiceLayer)layer).WebServiceClass.Envelope != null)
{
sRef = ((IWebServiceLayer)layer).WebServiceClass.SpatialReference;
classEnv = ((IWebServiceLayer)layer).WebServiceClass.Envelope;
}
if (classEnv != null)
{
if (sRef != null && !sRef.Equals(map.Display.SpatialReference))
{
bool found = false;
foreach (string p in map.Display.SpatialReference.Parameters)
{
if (p.ToLower().Trim() == "+nadgrids=@null")
{
found = false;
}
}
if (found)
{
classEnv = null;
}
else
{
IGeometry geom = GeometricTransformerFactory.Transform2D(classEnv.ToPolygon(0), sRef, map.Display.SpatialReference);
if (geom != null)
{
classEnv = geom.Envelope;
}
else
{
classEnv = null;
}
}
}
if (classEnv != null)
{
if (env == null)
{
env = new Envelope(classEnv);
}
else
{
env.Union(classEnv);
}
}
}
map.AddLayer(layer);
}
//map.AddDataset(dataset, 0);
if (env != null && map.Display != null)
{
if (firstDataset)
{
map.Display.Limit = env;
map.Display.ZoomTo(env);
}
else
{
IEnvelope limit = map.Display.Limit;
limit.Union(env);
map.Display.Limit = limit;
}
}
((MapEvent)MapEvent).drawPhase = DrawPhase.All;
((MapEvent)MapEvent).refreshMap = true;
}
return(true);
}
async static public Task <IFeatureCursor> Create(OgcSpatialFeatureclass fc, IQueryFilter filter)
{
var featureCursor = new OgcSpatialFeatureCursor(fc, filter);
if (fc == null || fc.Dataset == null)
{
return(featureCursor);
}
featureCursor._idField = fc.IDFieldName;
if (filter is ISpatialFilter)
{
featureCursor._spatialfilter = (ISpatialFilter)filter;
}
try
{
if (fc.SpatialReference != null &&
filter is ISpatialFilter &&
((ISpatialFilter)filter).FilterSpatialReference != null &&
!((ISpatialFilter)filter).FilterSpatialReference.Equals(fc.SpatialReference))
{
filter = (ISpatialFilter)filter.Clone();
((ISpatialFilter)filter).Geometry =
GeometricTransformerFactory.Transform2D(((ISpatialFilter)filter).Geometry,
((ISpatialFilter)filter).FilterSpatialReference,
fc.SpatialReference);
((ISpatialFilter)filter).FilterSpatialReference = null;
if (((ISpatialFilter)filter).SpatialRelation == spatialRelation.SpatialRelationMapEnvelopeIntersects &&
((ISpatialFilter)filter).Geometry != null)
{
((ISpatialFilter)filter).Geometry = ((ISpatialFilter)filter).Geometry.Envelope;
}
featureCursor._spatialfilter = (ISpatialFilter)filter;
}
DbCommand command = ((OgcSpatialDataset)fc.Dataset).SelectCommand(
fc, filter, out featureCursor._shapeField);
if (command == null)
{
return(featureCursor);
}
featureCursor._subFields = filter.QuerySubFields.ToArray();
featureCursor._conn = ((OgcSpatialDataset)fc.Dataset).ProviderFactory.CreateConnection();
featureCursor._conn.ConnectionString = fc.Dataset.ConnectionString;
command.Connection = featureCursor._conn;
if (featureCursor._conn.State != ConnectionState.Closed)
{
try
{
featureCursor._conn.Close();
}
catch { }
}
await featureCursor._conn.OpenAsync();
command.SetCustomCursorTimeout();
featureCursor._reader = await command.ExecuteReaderAsync();
return(featureCursor);
}
catch (Exception ex)
{
if (featureCursor._fc != null)
{
featureCursor._fc.LastException = ex;
}
if (featureCursor._conn != null && featureCursor._conn.State != ConnectionState.Closed)
{
featureCursor._conn.Close();
featureCursor._conn = null;
}
fc.LastException = ex;
return(null);
}
}
async static Task <int> Main(string[] args)
{
try
{
string cmd = "fill", jsonFile = (args.Length == 1 && args[0] != "fill" ? args[0] : String.Empty), indexUrl = String.Empty, indexName = String.Empty, category = String.Empty;
string proxyUrl = String.Empty, proxyUser = String.Empty, proxyPassword = String.Empty;
string basicAuthUser = String.Empty, basicAuthPassword = String.Empty;
int packageSize = 50000;
bool replace = false;
for (int i = 0; i < args.Length; i++)
{
if (args[i] == "fill" && i < args.Length - 1)
{
cmd = "fill";
jsonFile = args[i + 1];
i++;
}
if (args[i] == "remove-category")
{
cmd = "remove-category";
}
if (args[i] == "-s" && i < args.Length - 1)
{
indexUrl = args[i + 1];
}
if (args[i] == "-i" && i < args.Length - 1)
{
indexName = args[i + 1];
}
if (args[i] == "-c" && i < args.Length - 1)
{
category = args[i + 1];
}
if (args[i] == "-r")
{
replace = true;
}
if (args[i] == "-packagesize" && i < args.Length - 1)
{
packageSize = int.Parse(args[i + 1]);
}
#region Proxy
if (args[i] == "-proxy")
{
proxyUrl = args[i + 1];
}
if (args[i] == "-proxy-user")
{
proxyUser = args[i + 1];
}
if (args[i] == "-proxy-pwd")
{
proxyPassword = args[i + 1];
}
#endregion
#region Basic Authentication
if (args[i] == "-basic-auth-user")
{
basicAuthUser = args[i + 1];
}
if (args[i] == "-basic-auth-pwd")
{
basicAuthPassword = args[i + 1];
}
#endregion
}
if (args.Length == 0)
{
Console.WriteLine("Usage: gView.Cmd.ElasticSearch fill|remove-catetory [Options]");
return(1);
}
//gView.Framework.system.SystemVariables.CustomApplicationDirectory =
// System.IO.Path.GetDirectoryName(Assembly.GetEntryAssembly().Location);
Console.WriteLine("Environment");
Console.WriteLine("Working Directory: " + gView.Framework.system.SystemVariables.StartupDirectory);
Console.WriteLine("64Bit=" + gView.Framework.system.Wow.Is64BitProcess);
if (cmd == "fill")
{
#region Fill Index (with Json File)
var importConfig = JsonConvert.DeserializeObject <ImportConfig>(File.ReadAllText(jsonFile));
if (importConfig?.Connection == null)
{
throw new Exception("Invalid config. No connection defined");
}
var httpClientHandler = new HttpClientHandler();
if (!String.IsNullOrEmpty(proxyUrl))
{
httpClientHandler.Proxy = new WebProxy
{
Address = new Uri(proxyUrl),
BypassProxyOnLocal = false,
UseDefaultCredentials = false,
Credentials = new NetworkCredential(proxyUser, proxyPassword)
};
}
var httpClient = new HttpClient(handler: httpClientHandler, disposeHandler: true);
if (!String.IsNullOrEmpty(basicAuthUser))
{
var byteArray = Encoding.ASCII.GetBytes($"{ basicAuthUser }:{ basicAuthPassword }");
httpClient.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Basic", Convert.ToBase64String(byteArray));
}
using (var luceneServerClient = new LuceneServerClient(
importConfig.Connection.Url,
importConfig.Connection.DefaultIndex,
httpClient: httpClient))
{
if (importConfig.Connection.DeleteIndex)
{
await luceneServerClient.RemoveIndexAsync();
}
if (!await luceneServerClient.CreateIndexAsync())
{
throw new Exception($"Can't create elasticsearch index { importConfig.Connection.DefaultIndex }");
}
if (!await luceneServerClient.MapAsync(new SearchIndexMapping()))
{
throw new Exception($"Can't map item in elasticsearch index { importConfig.Connection.DefaultIndex }");
}
ISpatialReference sRefTarget = SpatialReference.FromID("epsg:4326");
Console.WriteLine("Target Spatial Reference: " + sRefTarget.Name + " " + String.Join(" ", sRefTarget.Parameters));
foreach (var datasetConfig in importConfig.Datasets)
{
if (datasetConfig.FeatureClasses == null)
{
continue;
}
IDataset dataset = new PlugInManager().CreateInstance(datasetConfig.DatasetGuid) as IDataset;
if (dataset == null)
{
throw new ArgumentException("Can't load dataset with guid " + datasetConfig.DatasetGuid.ToString());
}
await dataset.SetConnectionString(datasetConfig.ConnectionString);
await dataset.Open();
foreach (var featureClassConfig in datasetConfig.FeatureClasses)
{
var itemProto = featureClassConfig.IndexItemProto;
if (itemProto == null)
{
continue;
}
string metaId = Guid.NewGuid().ToString("N").ToLower();
category = featureClassConfig.Category;
if (!String.IsNullOrWhiteSpace(category))
{
var meta = new Meta()
{
Id = metaId,
Category = category,
Descrption = featureClassConfig.Meta?.Descrption,
Sample = featureClassConfig?.Meta.Sample,
Service = featureClassConfig?.Meta.Service,
Query = featureClassConfig?.Meta.Query
};
if (!await luceneServerClient.AddCustomMetadataAsync(metaId, JsonConvert.SerializeObject(meta)))
{
throw new Exception($"Can't index meta item in elasticsearch index { importConfig.Connection.MetaIndex }");
}
}
bool useGeometry = featureClassConfig.UserGeometry;
IDatasetElement dsElement = await dataset.Element(featureClassConfig.Name);
if (dsElement == null)
{
throw new ArgumentException("Unknown dataset element " + featureClassConfig.Name);
}
IFeatureClass fc = dsElement.Class as IFeatureClass;
if (fc == null)
{
throw new ArgumentException("Dataobject is not a featureclass " + featureClassConfig.Name);
}
Console.WriteLine("Index " + fc.Name);
Console.WriteLine("=====================================================================");
QueryFilter filter = new QueryFilter();
filter.SubFields = "*";
if (!String.IsNullOrWhiteSpace(featureClassConfig.Filter))
{
filter.WhereClause = featureClassConfig.Filter;
Console.WriteLine("Filter: " + featureClassConfig.Filter);
}
List <Dictionary <string, object> > items = new List <Dictionary <string, object> >();
int count = 0;
ISpatialReference sRef = fc.SpatialReference ?? SpatialReference.FromID("epsg:" + featureClassConfig.SRefId);
Console.WriteLine("Source Spatial Reference: " + sRef.Name + " " + String.Join(" ", sRef.Parameters));
Console.WriteLine("IDField: " + fc.IDFieldName);
using (var transformer = GeometricTransformerFactory.Create())
{
if (useGeometry)
{
transformer.SetSpatialReferences(sRef, sRefTarget);
}
IFeatureCursor cursor = await fc.GetFeatures(filter);
IFeature feature;
while ((feature = await cursor.NextFeature()) != null)
{
var indexItem = ParseFeature(metaId, category, feature, itemProto, useGeometry, transformer, featureClassConfig);
items.Add(indexItem);
count++;
if (items.Count >= packageSize)
{
if (!await luceneServerClient.IndexDocumentsAsync(items.ToArray()))
{
throw new Exception($"Error on indexing { items.Count } items on elasticsearch index { importConfig.Connection.DefaultIndex }");
}
items.Clear();
Console.Write(count + "...");
}
}
if (items.Count > 0)
{
if (!await luceneServerClient.IndexDocumentsAsync(items.ToArray()))
{
throw new Exception($"Error on indexing { items.Count } items on elasticsearch index { importConfig.Connection.DefaultIndex }");
}
Console.WriteLine(count + "...finish");
}
}
}
}
}
#endregion
}
else if (cmd == "remove-category")
{
#region Remove Category
//RemoveCategory(indexUrl, indexName, replace ? Replace(category) : category,
// proxyUrl, proxyUser, proxyPassword,
// basicAuthUser, basicAuthPassword);
#endregion
}
return(0);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Console.WriteLine(ex.StackTrace);
return(1);
}
}
static void TestProj4()
{
var sRef4326 = SpatialReference.FromID("epsg:4326");
var sRef31255 = SpatialReference.FromID("epsg:31255");
var sRef31256 = SpatialReference.FromID("epsg:31256");
var sRef3857 = SpatialReference.FromID("epsg:3857");
var sRef23032 = new SpatialReference("test", "", "+proj=utm +zone=32 +ellps=intl +towgs84=-87,-98,-121,0,0,0,0 +units=m +no_defs ", null);
using (var transformer = GeometricTransformerFactory.Create())
{
//var point = new Point(1443413.9574, 6133464.20414);
////var point = new Point(-27239.046, 335772.696625);
//Console.WriteLine(point.X.ToString() + " " + point.Y.ToString());
//transformer.SetSpatialReferences(sRef3857, sRef4326);
//point = (Point)transformer.Transform2D(point);
//Console.WriteLine(point.X.ToString() + " " + point.Y.ToString());
var pCollection = new PointCollection();
//pCollection.AddPoint(new Point(1443413.9574, 6133464.20414));
pCollection.AddPoint(new Point(-27239.046, 335772.696625));
Console.WriteLine(pCollection[0].X.ToString() + " " + pCollection[0].Y.ToString());
transformer.SetSpatialReferences(sRef31255, sRef3857);
pCollection = (PointCollection)transformer.Transform2D(pCollection);
Console.WriteLine(pCollection[0].X.ToString() + " " + pCollection[0].Y.ToString());
//transformer.SetSpatialReferences(sRef3857, sRef4326);
//point = (Point)transformer.Transform2D(point);
//Console.WriteLine(point.X.ToString() + " " + point.Y.ToString());
//transformer.SetSpatialReferences(sRef4326, sRef31255);
//point = (Point)transformer.Transform2D(point);
//Console.WriteLine(point.X.ToString() + " " + point.Y.ToString());
//var point = new Point(-27239.046, 335772.696625);
//Console.WriteLine(point.X.ToString() + " " + point.Y.ToString());
//transformer.SetSpatialReferences(sRef31255, sRef23032);
//var point2 = (Point)transformer.Transform2D(point);
//Console.WriteLine(point2.X.ToString() + " " + point2.Y.ToString());
//transformer.SetSpatialReferences(sRef31255, sRef31256);
//point2 = (Point)transformer.Transform2D(point);
//Console.WriteLine(point2.X.ToString() + " " + point2.Y.ToString());
//transformer.SetSpatialReferences(sRef31256, sRef3857);
//point=(Point)transformer.Transform2D(point);
//Console.WriteLine(point.X.ToString() + " " + point.Y.ToString());
//transformer.SetSpatialReferences(sRef4326, sRef3857);
//point = (Point)transformer.Transform2D(point);
//Console.WriteLine(point.X.ToString() + " " + point.Y.ToString());
}
}
public void AddFeature(IFeature feature, ISpatialReference sRef, IFeatureLayer layer, string Category, IFields fields, IField primaryDisplayField)
{
if (feature == null)
{
return;
}
if (layer != null)
{
if (fields == null)
{
fields = layer.Fields;
}
if (primaryDisplayField == null)
{
primaryDisplayField = layer.Fields.PrimaryDisplayField;
}
}
if (Category == "")
{
Category = "Results";
}
CategoryTreeNode parent = null;
foreach (CategoryTreeNode node in treeObjects.Nodes)
{
if (node.Category == Category)
{
parent = node;
break;
}
}
if (parent == null)
{
parent = new CategoryTreeNode(Category, _doc, layer);
treeObjects.Nodes.Add(parent);
}
parent.Nodes.Add(new FeatureTreeNode(_doc, feature, sRef, layer, (primaryDisplayField != null) ? primaryDisplayField.name : "", 1));
if (fields != null && feature.Fields != null)
{
List <FieldValue> fvs = gView.Framework.system.ListOperations <FieldValue> .Clone(feature.Fields);
feature.Fields.Clear();
foreach (IField field in fields.ToEnumerable())
{
if (!field.visible)
{
continue;
}
for (int i = 0; i < fvs.Count; i++)
{
if (fvs[i].Name == field.name)
{
feature.Fields.Add(new FieldValue(field.aliasname, fvs[i].Value));
fvs.RemoveAt(i);
break;
}
}
}
}
if (treeObjects.SelectedNode == null)
{
treeObjects.SelectedNode = parent.Nodes[0];
if (_doc != null && _doc.FocusMap != null && _doc.FocusMap.Display != null)
{
IGeometry shape = feature.Shape;
if (sRef != null && !sRef.Equals(_doc.FocusMap.Display.SpatialReference))
{
shape = GeometricTransformerFactory.Transform2D(shape, sRef, _doc.FocusMap.Display.SpatialReference);
}
_doc.FocusMap.HighlightGeometry(shape, 300);
}
//parent.ExpandAll();
parent.Expand();
if (parent.Nodes.Count > 0)
{
parent.Nodes[0].Expand();
}
}
}
private void cmbEpsg_SelectedIndexChanged(object sender, EventArgs e)
{
lstScales.Items.Clear();
if (_metadata == null)
{
return;
}
ISpatialReference sRef = SpatialReference.FromID("epsg:" + cmbEpsg.SelectedItem.ToString());
if (sRef == null)
{
return;
}
IEnvelope extent = _metadata.GetEPSGEnvelope((int)cmbEpsg.SelectedItem);
if (extent == null)
{
return;
}
double width = extent.Width;
double height = extent.Height;
double dpu = 1.0;
if (sRef.SpatialParameters.IsGeographic)
{
GeoUnitConverter converter = new GeoUnitConverter();
dpu = converter.Convert(1.0, GeoUnits.Meters, GeoUnits.DecimalDegrees);
}
foreach (double scale in _metadata.Scales)
{
double tileWidth = (double)_metadata.TileWidth * (double)scale / (96.0 / 0.0254);
double tileHeight = (double)_metadata.TileHeight * (double)scale / (96.0 / 0.0254);
tileWidth *= dpu;
tileHeight *= dpu;
int tx = (int)Math.Floor(width / tileWidth) + 1;
int ty = (int)Math.Floor(height / tileHeight) + 1;
lstScales.Items.Add(new ListViewItem(new string[] { scale.ToString(_nhi), ty.ToString(), tx.ToString(), (tx * ty).ToString() }));
lstScales.Items[lstScales.Items.Count - 1].Checked = true;
}
if (!Envelope.IsNull(this.CurrentExtent) &&
cmbEpsg.SelectedItem != null)
{
ISpatialReference oldSRef = SpatialReference.FromID(lblEpsg.Text.Replace("(", "").Replace(")", ""));
ISpatialReference newSRef = SpatialReference.FromID("epsg:" + cmbEpsg.SelectedItem.ToString());
using (var geometricTransformer = GeometricTransformerFactory.Create())
{
geometricTransformer.SetSpatialReferences(oldSRef, newSRef);
IGeometry geom = geometricTransformer.Transform2D(this.CurrentExtent) as IGeometry;
if (geom != null)
{
this.CurrentExtent = geom.Envelope;
}
}
}
lblEpsg.Text = "(EPSG:" + (cmbEpsg.SelectedItem != null ? cmbEpsg.SelectedItem.ToString() : "0") + ")";
}
async private Task <bool> ImportToNewFeatureclass(IFeatureDataset destDS, string fcname, IFeatureClass sourceFC, FieldTranslation fieldTranslation, bool project, List <IQueryFilter> filters, DatasetNameCase namecase, geometryType?sourceGeometryType = null)
{
if (!_cancelTracker.Continue)
{
return(true);
}
switch (namecase)
{
case DatasetNameCase.upper:
fcname = fcname.ToUpper();
fieldTranslation.ToUpper();
break;
case DatasetNameCase.lower:
fcname = fcname.ToLower();
fieldTranslation.ToLower();
break;
case DatasetNameCase.classNameUpper:
fcname = fcname.ToUpper();
break;
case DatasetNameCase.classNameLower:
fcname = fcname.ToLower();
break;
case DatasetNameCase.fieldNamesUpper:
fieldTranslation.ToUpper();
break;
case DatasetNameCase.fieldNamesLower:
fieldTranslation.ToLower();
break;
}
try
{
fcname = fcname.Replace(".", "_");
if (destDS == null)
{
_errMsg = "Argument Exception";
return(false);
}
IFeatureDatabase fdb = destDS.Database as IFeatureDatabase;
if (!(fdb is IFeatureUpdater))
{
_errMsg = "Database don't implement IFeatureUpdater...";
return(false);
}
IDatasetElement destLayer = await destDS.Element(fcname);
if (destLayer != null)
{
if (ReportRequest != null)
{
RequestArgs args = new RequestArgs(
"Featureclass " + fcname + " already exists in database\nDo want to replace it?",
MessageBoxButtons.YesNoCancel,
DialogResult.Cancel);
ReportRequest(this, args);
switch (args.Result)
{
case DialogResult.No:
return(true);
case DialogResult.Cancel:
_errMsg = "Import is canceled by the user...";
return(false);
}
}
}
if (destLayer != null)
{
await fdb.DeleteFeatureClass(fcname);
}
GeometryDef geomDef = new GeometryDef(sourceFC);
if (geomDef.GeometryType == geometryType.Unknown && sourceGeometryType != null)
{
geomDef.GeometryType = sourceGeometryType.Value;
}
int fcID = await fdb.CreateFeatureClass(destDS.DatasetName,
fcname,
geomDef,
(fieldTranslation == null)?
((sourceFC.Fields != null) ? (IFields)sourceFC.Fields.Clone() : new Fields()) :
fieldTranslation.DestinationFields);
if (fcID < 0)
{
_errMsg = "Can't create featureclass " + fcname + "...\r\n" + fdb.LastErrorMessage;
destDS.Dispose();
return(false);
}
destLayer = await destDS.Element(fcname);
if (destLayer == null || !(destLayer.Class is IFeatureClass))
{
_errMsg = "Can't load featureclass " + fcname + "...\r\n" + destDS.LastErrorMessage;
destDS.Dispose();
return(false);
}
IFeatureClass destFC = destLayer.Class as IFeatureClass;
if (project && destFC.SpatialReference != null && !destFC.SpatialReference.Equals(sourceFC.SpatialReference))
{
_transformer = GeometricTransformerFactory.Create();
//_transformer.FromSpatialReference = sourceFC.SpatialReference;
//_transformer.ToSpatialReference = destFC.SpatialReference;
_transformer.SetSpatialReferences(sourceFC.SpatialReference, destFC.SpatialReference);
}
var importBufferSizeAttribute = destFC.GetType().GetCustomAttribute <ImportFeaturesBufferSizeAttribute>();
if (importBufferSizeAttribute != null && importBufferSizeAttribute.BufferSize > 0)
{
this.FeatureBufferSize = importBufferSizeAttribute.BufferSize;
}
if (_cancelTracker.Continue)
{
bool result = true;
if (fdb is IFeatureImportEvents)
{
((IFeatureImportEvents)fdb).BeforeInsertFeaturesEvent(sourceFC, destFC);
}
if (!_schemaOnly)
{
result = await CopyFeatures(sourceFC, fdb, destFC, fieldTranslation, filters);
}
if (!result)
{
await fdb.DeleteFeatureClass(fcname);
destDS.Dispose();
return(false);
}
if (fdb is IFeatureImportEvents)
{
((IFeatureImportEvents)fdb).AfterInsertFeaturesEvent(sourceFC, destFC);
}
}
if (fdb is IFileFeatureDatabase)
{
if (!((IFileFeatureDatabase)fdb).Flush(destFC))
{
_errMsg = "Error executing flush for file database..." + fdb.LastErrorMessage;
return(false);
}
}
destDS.Dispose();
if (_cancelTracker.Continue)
{
return(true);
}
else
{
await fdb.DeleteFeatureClass(fcname);
_errMsg = "Import is canceled by the user...";
return(false);
}
}
finally
{
if (_transformer != null)
{
_transformer.Release();
_transformer = null;
}
}
}
async override public Task <bool> RefreshMap(DrawPhase phase, ICancelTracker cancelTracker)
{
base.ResetRequestExceptions();
if (_canvas != null && phase == DrawPhase.Graphics)
{
return(true);
}
this.ZoomTo(m_actMinX, m_actMinY, m_actMaxX, m_actMaxY);
if (cancelTracker == null)
{
cancelTracker = new CancelTracker();
}
using (var datasetCachingContext = new DatasetCachingContext(this))
using (var geoTransformer = GeometricTransformerFactory.Create())
{
//geoTransformer.ToSpatialReference = this.SpatialReference;
if (_bitmap == null)
{
_bitmap = Current.Engine.CreateBitmap(iWidth, iHeight, PixelFormat.Rgba32);
}
_canvas = _bitmap.CreateCanvas();
//_canvas.CompositingMode = CompositingMode.SourceCopy;
//this.dpi = _canvas.DpiX * this.ScaleSymbolFactor;
if (BackgroundColor.A != 0 && !Display.MakeTransparent)
{
using (var brush = Current.Engine.CreateSolidBrush(BackgroundColor))
{
_canvas.FillRectangle(brush, new CanvasRectangle(0, 0, _bitmap.Width, _bitmap.Height));
}
}
if (phase == DrawPhase.All || phase == DrawPhase.Geography)
{
this.GeometricTransformer = geoTransformer;
// Thread für MapServer Datasets starten...
#region WebServiceLayer
List <IWebServiceLayer> webServices;
if (this.TOC != null)
{
webServices = ListOperations <IWebServiceLayer> .Swap(this.TOC.VisibleWebServiceLayers);
}
else
{
webServices = new List <IWebServiceLayer>();
foreach (IDatasetElement layer in this.MapElements)
{
if (!(layer is IWebServiceLayer))
{
continue;
}
if (((ILayer)layer).Visible)
{
webServices.Add((IWebServiceLayer)layer);
}
}
}
int webServiceOrder = 0, webServiceOrder2 = 1;
foreach (IWebServiceLayer element in webServices)
{
if (!element.Visible)
{
continue;
}
IWebServiceLayer wsLayer = LayerFactory.Create(element.WebServiceClass.Clone() as IClass, element) as IWebServiceLayer;
if (wsLayer == null || wsLayer.WebServiceClass == null)
{
continue;
}
wsLayer.WebServiceClass.SpatialReference = this.SpatialReference;
List <IWebServiceClass> additionalWebServices = new List <IWebServiceClass>();
if (BeforeRenderLayers != null)
{
List <ILayer> modLayers = new List <ILayer>();
foreach (IWebServiceTheme theme in wsLayer.WebServiceClass.Themes)
{
if (theme is ILayer)
{
modLayers.Add(theme);
}
}
BeforeRenderLayers(this, modLayers);
foreach (ILayer additionalLayer in MapServerHelper.FindAdditionalWebServiceLayers(wsLayer.WebServiceClass, modLayers))
{
IWebServiceClass additionalWebService = MapServerHelper.CloneNonVisibleWebServiceClass(wsLayer.WebServiceClass);
MapServerHelper.CopyWebThemeProperties(additionalWebService, additionalLayer);
if (MapServerHelper.HasVisibleThemes(additionalWebService))
{
additionalWebServices.Add(additionalWebService);
}
}
}
var srt = new RenderServiceRequest(this, wsLayer, webServiceOrder++);
srt.finish += new RenderServiceRequest.RequestThreadFinished(MapRequestThread_finished);
//Thread thread = new Thread(new ThreadStart(srt.ImageRequest));
m_imageMerger.max++;
//thread.Start();
var task = srt.ImageRequest(); // start Task and continue...
foreach (IWebServiceClass additionalWebService in additionalWebServices)
{
wsLayer = LayerFactory.Create(additionalWebService, element) as IWebServiceLayer;
if (wsLayer == null || wsLayer.WebServiceClass == null)
{
continue;
}
wsLayer.WebServiceClass.SpatialReference = this.SpatialReference;
srt = new RenderServiceRequest(this, wsLayer, (++webServiceOrder2) + webServices.Count);
srt.finish += new RenderServiceRequest.RequestThreadFinished(MapRequestThread_finished);
//thread = new Thread(new ThreadStart(srt.ImageRequest));
m_imageMerger.max++;
//thread.Start();
var additionalTask = srt.ImageRequest(); // start task and continue...
}
}
#endregion
List <ILayer> layers = new List <ILayer>();
if (this.TOC != null)
{
if (this.GetType().Equals(typeof(ServiceMap)))
{
layers = ListOperations <ILayer> .Swap(this.TOC.Layers);
}
else
{
layers = ListOperations <ILayer> .Swap(this.TOC.VisibleLayers);
}
}
else
{
layers = new List <ILayer>();
foreach (IDatasetElement layer in this.MapElements)
{
if (!(layer is ILayer))
{
continue;
}
if (((ILayer)layer).Visible)
{
layers.Add((ILayer)layer);
}
}
}
if (BeforeRenderLayers != null)
{
//
// Kopie der Original Layer erstellen
// ACHTUNG: Renderer werden nicht kopiert!
// dürfen in BeforeRenderLayers nicht verändert werden...
// Eine zuweisung eines neuen Renderers ist jedoch legitim.
//
List <ILayer> modLayers = new List <ILayer>();
foreach (IDatasetElement element in layers)
{
if (!(element is ILayer) || element is IWebServiceTheme)
{
continue;
}
ILayer layer = (ILayer)element;
if (layer.MinimumScale > 1 && layer.MinimumScale > this.mapScale)
{
continue;
}
if (layer.MaximumScale > 1 && layer.MaximumScale < this.mapScale)
{
continue;
}
modLayers.Add(LayerFactory.Create(layer.Class, layer));
}
BeforeRenderLayers(this, modLayers);
layers = modLayers;
}
//layers = ModifyLayerList(layers);
List <IFeatureLayer> labelLayers = this.OrderedLabelLayers(layers);
LabelEngine.Init(this.Display, false);
foreach (IDatasetElement element in layers)
{
if (!cancelTracker.Continue)
{
break;
}
if (!(element is ILayer))
{
continue;
}
ILayer layer = (ILayer)element;
//if (_ceckLayerVisibilityBeforeDrawing)
//{
// if (!LayerIsVisible(layer)) continue;
//}
if (!layer.Visible)
{
continue;
}
if (!layer.RenderInScale(this))
{
continue;
}
#if (DEBUG)
//Logger.LogDebug("Drawing Layer:" + element.Title);
#endif
SetGeotransformer((ILayer)element, geoTransformer);
if (layer is IFeatureLayer)
{
if (layer.Class?.Dataset is IFeatureCacheDataset)
{
await((IFeatureCacheDataset)layer.Class.Dataset).InitFeatureCache(datasetCachingContext);
}
IFeatureLayer fLayer = (IFeatureLayer)layer;
if (fLayer.FeatureRenderer == null &&
(
fLayer.LabelRenderer == null ||
(fLayer.LabelRenderer != null && fLayer.LabelRenderer.RenderMode != LabelRenderMode.RenderWithFeature)
))
{
//continue;
}
else
{
RenderFeatureLayer rlt = new RenderFeatureLayer(this, datasetCachingContext, fLayer, cancelTracker, new FeatureCounter());
if (fLayer.LabelRenderer != null && fLayer.LabelRenderer.RenderMode == LabelRenderMode.RenderWithFeature)
{
rlt.UseLabelRenderer = true;
}
else
{
rlt.UseLabelRenderer = labelLayers.IndexOf(fLayer) == 0; // letzten Layer gleich mitlabeln
}
if (rlt.UseLabelRenderer)
{
labelLayers.Remove(fLayer);
}
await rlt.Render();
}
//thread = new Thread(new ThreadStart(rlt.Render));
//thread.Start();
}
if (layer is IRasterLayer && ((IRasterLayer)layer).RasterClass != null)
{
IRasterLayer rLayer = (IRasterLayer)layer;
if (rLayer.RasterClass.Polygon == null)
{
continue;
}
IEnvelope dispEnvelope = this.Envelope;
if (Display.GeometricTransformer != null)
{
dispEnvelope = ((IGeometry)Display.GeometricTransformer.InvTransform2D(dispEnvelope)).Envelope;
}
if (gView.Framework.SpatialAlgorithms.Algorithm.IntersectBox(rLayer.RasterClass.Polygon, dispEnvelope))
{
if (rLayer.Class is IParentRasterLayer)
{
await DrawRasterParentLayer((IParentRasterLayer)rLayer.Class, cancelTracker, rLayer);
}
else
{
RenderRasterLayer rlt = new RenderRasterLayer(this, rLayer, rLayer, cancelTracker);
await rlt.Render();
//thread = new Thread(new ThreadStart(rlt.Render));
//thread.Start();
}
}
}
// Andere Layer (zB IRasterLayer)
#if (DEBUG)
//Logger.LogDebug("Finished drawing layer: " + element.Title);
#endif
}
// Label Features
if (labelLayers.Count != 0)
{
foreach (IFeatureLayer fLayer in labelLayers)
{
this.SetGeotransformer(fLayer, geoTransformer);
if (!fLayer.Visible)
{
continue;
}
RenderLabel rlt = new RenderLabel(this, fLayer, cancelTracker, new FeatureCounter());
await rlt.Render();
}
}
LabelEngine.Draw(this.Display, cancelTracker);
LabelEngine.Release();
if (cancelTracker.Continue)
{
while (m_imageMerger.Count < m_imageMerger.max)
{
await Task.Delay(10);
}
}
if (_drawScaleBar)
{
m_imageMerger.mapScale = this.mapScale;
m_imageMerger.dpi = this.dpi;
}
#if (DEBUG)
//Logger.LogDebug("Merge Images");
#endif
m_imageMerger.Merge(_bitmap, this.Display);
m_imageMerger.Clear();
#if (DEBUG)
//Logger.LogDebug("Merge Images Finished");
#endif
}
if (phase == DrawPhase.All || phase == DrawPhase.Graphics)
{
foreach (IGraphicElement grElement in Display.GraphicsContainer.Elements)
{
grElement.Draw(Display);
}
}
base.AppendRequestExceptionsToImage();
if (_canvas != null)
{
_canvas.Dispose();
}
_canvas = null;
this.GeometricTransformer = null;
}
return(this.HasRequestExceptions == false);
}
private void btnOK_Click(object sender, EventArgs e)
{
if (_map == null || _display == null)
{
return;
}
try
{
bool refresh = false;
_map.Name = txtName.Text;
_display.refScale = Convert.ToDouble(numRefScale.Value);
if (cmbMapUnits.Enabled)
{
_display.MapUnits = ((GeoUnitsItem)cmbMapUnits.SelectedItem).Unit;
}
_display.DisplayUnits = ((GeoUnitsItem)cmbDisplayUnits.SelectedItem).Unit;
_display.BackgroundColor = btnBackgroundColor.BackColor.ToArgbColor();
ISpatialReference oldSRef = _display.SpatialReference;
_display.SpatialReference = _sr.SpatialReference;
if (oldSRef != null &&
!oldSRef.Equals(_display.SpatialReference))
{
IEnvelope limit = _display.Limit;
IEnvelope env = _display.Envelope;
_display.Limit = GeometricTransformerFactory.Transform2D(
limit,
oldSRef,
_display.SpatialReference).Envelope;
_display.ZoomTo(
GeometricTransformerFactory.Transform2D(
env,
oldSRef,
_display.SpatialReference).Envelope
);
}
_map.LayerDefaultSpatialReference = _sr2.SpatialReference;
_map.Title = txtTitle.Text;
_map.SetLayerDescription(Map.MapDescriptionId, txtDescription.Text);
_map.SetLayerCopyrightText(Map.MapCopyrightTextId, txtCopyright.Text);
if (SystemVariables.SystemFontsScaleFactor != (float)numFontScaleFactor.Value / 100f)
{
SystemVariables.SystemFontsScaleFactor = (float)numFontScaleFactor.Value / 100f;
_display.Screen?.RefreshSettings();
refresh = true;
}
#region Graphics Engine
if (cmbGraphicsEngine.SelectedItem.ToString() != GraphicsEngine.Current.Engine.EngineName)
{
var engine = Engines.RegisteredGraphcisEngines().Where(ge => ge.EngineName == cmbGraphicsEngine.SelectedItem.ToString()).FirstOrDefault();
if (engine != null)
{
GraphicsEngine.Current.Engine = engine;
RefreshFeatureRendererSymbolsGraphcisEngine();
refresh = true;
}
}
#endregion Graphics Engine
if (refresh)
{
if (_app != null)
{
_app.RefreshTOC();
_app.RefreshActiveMap(DrawPhase.All);
}
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
async public Task <bool> MapRequest(gView.Framework.Carto.IDisplay display)
{
if (_srs == null)
{
return(false);
}
if (!_dataset.IsOpened)
{
if (!await _dataset.Open())
{
return(false);
}
}
List <IWebServiceTheme> themes = Themes;
if (themes == null)
{
return(false);
}
#region Check for visible Layers
bool visFound = false;
foreach (IWebServiceTheme theme in themes)
{
if (!theme.Visible)
{
continue;
}
if (theme.MinimumScale > 1 && theme.MinimumScale > display.mapScale)
{
continue;
}
if (theme.MaximumScale > 1 && theme.MaximumScale < display.mapScale)
{
continue;
}
visFound = true;
break;
}
if (!visFound)
{
if (_image != null)
{
_image.Dispose();
_image = null;
}
return(true);
}
#endregion Check for visible Layers
int iWidth = display.iWidth;
int iHeight = display.iHeight;
if (BeforeMapRequest != null)
{
ISpatialReference sRef = this.SpatialReference;
BeforeMapRequest(this, display, ref sRef, ref iWidth, ref iHeight);
if (sRef != null && sRef.Name.ToLower() != this.SRSCode.ToLower())
{
this.SRSCode = sRef.Name;
}
}
IEnvelope displayEnv = display.Envelope;
if (display.SpatialReference != null && !display.SpatialReference.Equals(this.SpatialReference))
{
displayEnv = GeometricTransformerFactory.Transform2D(displayEnv, display.SpatialReference, this.SpatialReference).Envelope;
iHeight = (int)((displayEnv.Height / displayEnv.Width) * iWidth);
}
StyledLayerDescriptorWriter sldWriter = null;
StringBuilder request = new StringBuilder("VERSION=1.1.1&REQUEST=GetMap");
StringBuilder layers = new StringBuilder(), styles = new StringBuilder();
foreach (IWebServiceTheme theme in themes)
{
if (!theme.Visible || theme.Locked ||
(!(theme.Class is WMSThemeClass) &&
!(theme.Class is WFSFeatureClass)))
{
continue;
}
if (layers.Length > 0)
{
layers.Append(",");
styles.Append(",");
}
layers.Append(theme.Class.Name);
if (theme.Class is IWMSStyle)
{
styles.Append(((IWMSStyle)theme.Class).Style);
}
if (theme.FeatureRenderer != null &&
_userDefinedSymbolization.SupportSLD &&
_userDefinedSymbolization.UserStyle)
{
SLDRenderer sldRenderer = null;
if (theme.FeatureRenderer is SLDRenderer)
{
sldRenderer = (SLDRenderer)theme.FeatureRenderer;
}
else
{
//if (theme.FilterQuery is ISpatialFilter)
//{
// IGeometry pGeometry = GeometricTransformer.Transform2D(
// ((ISpatialFilter)theme.FilterQuery).Geometry,
// display.SpatialReference,
// this.SpatialReference);
// IGeometry oGeometry = ((ISpatialFilter)theme.FilterQuery).Geometry;
// ((ISpatialFilter)theme.FilterQuery).Geometry = pGeometry;
// sldRenderer = new SLDRenderer(theme);
// ((ISpatialFilter)theme.FilterQuery).Geometry = oGeometry;
//}
//else
{
sldRenderer = await SLDRenderer.CreateAync(theme);
if (display.SpatialReference != null)
{
sldRenderer.SetDefaultSrsName(display.SpatialReference.Name);
}
}
}
if (sldWriter == null)
{
sldWriter = new StyledLayerDescriptorWriter();
}
sldWriter.WriteNamedLayer(theme.Class.Name, sldRenderer);
}
}
request.Append("&LAYERS=" + layers.ToString());
if (sldWriter != null)
{
string sld = sldWriter.ToLineString();
if (!_use_SLD_BODY && !string.IsNullOrEmpty(MapServerConfig.DefaultOutputPath))
{
string sldFilename = "style_" + Guid.NewGuid().ToString("N") + ".sld";
StreamWriter sw = new StreamWriter(MapServerConfig.DefaultOutputPath + @"/" + sldFilename);
sw.WriteLine(sldWriter.ToString());
sw.Close();
request.Append("&SLD=" + MapServerConfig.DefaultOutputUrl + "/" + sldFilename);
}
else
{
request.Append("&SLD_BODY=" + sld.Replace("#", "%23"));
}
}
else
{
request.Append("&STYLES=" + styles.ToString());
}
if (_exceptions != null && _exceptions.Formats.Count > 0)
{
request.Append("&EXCEPTIONS=" + _exceptions.Formats[0]);
}
request.Append("&SRS=" + _srs.Srs[_srs.SRSIndex]);
request.Append("&WIDTH=" + iWidth);
request.Append("&HEIGHT=" + iHeight);
request.Append("&FORMAT=" + _getMap.Formats[_getMap.FormatIndex]);
request.Append("&BBOX=" +
displayEnv.minx.ToString(_nhi) + "," +
displayEnv.miny.ToString(_nhi) + "," +
displayEnv.maxx.ToString(_nhi) + "," +
displayEnv.maxy.ToString(_nhi));
//request.Append("&BGCOLOR=FFFFFF");
request.Append("&TRANSPARENT=TRUE");
if (_image != null)
{
_image.Dispose();
_image = null;
}
IBitmap bitmap = null;
//if (_getMap.Post_OnlineResource != String.Empty && sldWriter != null)
//{
// //bm = WebFunctions.DownloadImage(WMSDataset.Append2Url(_getMap.Post_OnlineResource, request.ToString() + "&SLD="),
// // UTF8Encoding.UTF8.GetBytes(sldWriter.ToString()));
// bm = WebFunctions.DownloadImage(_getMap.Post_OnlineResource,
// UTF8Encoding.UTF8.GetBytes(request.ToString()));
//}
//else
{
#if (DEBUG)
gView.Framework.system.Logger.LogDebug("Start WMS DownloadImage");
#endif
string url = WMSDataset.Append2Url(_getMap.Get_OnlineResource, request.ToString());
try
{
bitmap = WebFunctions.DownloadImage(url,
ConfigTextStream.ExtractValue(_dataset._connectionString, "usr"),
ConfigTextStream.ExtractValue(_dataset._connectionString, "pwd"));
}
catch (Exception ex)
{
await WMSClass.ErrorLogAsync(display.Map as IServiceRequestContext, "MapRequest", url, ex);
return(false);
}
#if (DEBUG)
gView.Framework.system.Logger.LogDebug("WMS DownloadImage Finished");
#endif
}
if (bitmap != null)
{
_image = new GeorefBitmap(bitmap);
_image.Envelope = displayEnv;
_image.SpatialReference = this.SpatialReference;
if (AfterMapRequest != null)
{
AfterMapRequest(this, display, _image);
}
}
return(_image != null);
}
private void WmtsCapabilities100(IServiceRequestContext context, TileServiceMetadata metadata)
{
gView.Framework.OGC.WMTS.Version_1_0_0.Capabilities capabilities = new Framework.OGC.WMTS.Version_1_0_0.Capabilities()
{
version = "1.0.0"
};
capabilities.NameSpaces = new System.Xml.Serialization.XmlSerializerNamespaces();
capabilities.NameSpaces.Add("ows", "http://www.opengis.net/ows/1.1");
capabilities.NameSpaces.Add("xlink", "http://www.w3.org/1999/xlink");
capabilities.NameSpaces.Add("gml", "http://www.opengis.net/gml");
#region ServiceIndentification
capabilities.ServiceIdentification = new gView.Framework.OGC.WMTS.Version_1_0_0.ServiceIdentification();
capabilities.ServiceIdentification.Title = new gView.Framework.OGC.WMTS.Version_1_0_0.LanguageStringType[] { new gView.Framework.OGC.WMTS.Version_1_0_0.LanguageStringType()
{
Value = CapabilitiesMapName(context) // do not add folder to the name => tilecache will not work with arcgis
} };
capabilities.ServiceIdentification.ServiceType = new gView.Framework.OGC.WMTS.Version_1_0_0.CodeType()
{
Value = "OGC WMTS"
};
capabilities.ServiceIdentification.ServiceTypeVersion = new string[] { "1.0.0" };
#endregion
string restFulUrl;
if (String.IsNullOrWhiteSpace(context.ServiceRequest.Folder))
{
restFulUrl = context.ServiceRequest.OnlineResource.ToLower()
.Replace("/ogc/" + context.ServiceRequest.Service, "/tilewmts/" + context.ServiceRequest.Service);
}
else
{
string fromServiceFullname = context.ServiceRequest.Folder + "@" + context.ServiceRequest.Service;
string toServiceFullname = context.ServiceRequest.Folder + "/" + context.ServiceRequest.Service;
restFulUrl = context.ServiceRequest.OnlineResource.ToLower()
.Replace("/ogc/" + fromServiceFullname.ToLower(), "/tilewmts/" + toServiceFullname.ToLower());
}
#region OperationsMetadata
capabilities.OperationsMetadata = new gView.Framework.OGC.WMTS.Version_1_0_0.OperationsMetadata();
var getCapOperation = new gView.Framework.OGC.WMTS.Version_1_0_0.Operation()
{
name = "GetCapabilities"
};
getCapOperation.DCP = new gView.Framework.OGC.WMTS.Version_1_0_0.DCP[] { new gView.Framework.OGC.WMTS.Version_1_0_0.DCP() };
getCapOperation.DCP[0].Item = new gView.Framework.OGC.WMTS.Version_1_0_0.HTTP();
getCapOperation.DCP[0].Item.Items = new gView.Framework.OGC.WMTS.Version_1_0_0.RequestMethodType[] { new gView.Framework.OGC.WMTS.Version_1_0_0.RequestMethodType() };
getCapOperation.DCP[0].Item.Items[0].href = context.ServiceRequest.OnlineResource + "?SERVICE=WMTS&VERSION=1.0.0" + "&";
getCapOperation.DCP[0].Item.Items[0].Constraint = new gView.Framework.OGC.WMTS.Version_1_0_0.DomainType[] { new gView.Framework.OGC.WMTS.Version_1_0_0.DomainType() };
getCapOperation.DCP[0].Item.Items[0].Constraint[0].name = "GetEncoding";
getCapOperation.DCP[0].Item.Items[0].Constraint[0].AllowedValues = new object[] { new gView.Framework.OGC.WMTS.Version_1_0_0.ValueType()
{
Value = "KVP" /*"RESTful"*/
} };
getCapOperation.DCP[0].Item.ItemsElementName = new gView.Framework.OGC.WMTS.Version_1_0_0.ItemsChoiceType[] { gView.Framework.OGC.WMTS.Version_1_0_0.ItemsChoiceType.Get };
var getTileOperation = new gView.Framework.OGC.WMTS.Version_1_0_0.Operation()
{
name = "GetTile"
};
getTileOperation.DCP = new gView.Framework.OGC.WMTS.Version_1_0_0.DCP[] { new gView.Framework.OGC.WMTS.Version_1_0_0.DCP() };
getTileOperation.DCP[0].Item = new gView.Framework.OGC.WMTS.Version_1_0_0.HTTP();
getTileOperation.DCP[0].Item.Items = new gView.Framework.OGC.WMTS.Version_1_0_0.RequestMethodType[] { new gView.Framework.OGC.WMTS.Version_1_0_0.RequestMethodType() };
getTileOperation.DCP[0].Item.Items[0].href = restFulUrl;
getTileOperation.DCP[0].Item.Items[0].Constraint = new gView.Framework.OGC.WMTS.Version_1_0_0.DomainType[] { new gView.Framework.OGC.WMTS.Version_1_0_0.DomainType() };
getTileOperation.DCP[0].Item.Items[0].Constraint[0].name = "GetEncoding";
getTileOperation.DCP[0].Item.Items[0].Constraint[0].AllowedValues = new object[] { new gView.Framework.OGC.WMTS.Version_1_0_0.ValueType()
{
Value = "RESTful"
} };
getTileOperation.DCP[0].Item.ItemsElementName = new gView.Framework.OGC.WMTS.Version_1_0_0.ItemsChoiceType[] { gView.Framework.OGC.WMTS.Version_1_0_0.ItemsChoiceType.Get };
capabilities.OperationsMetadata.Operation = new gView.Framework.OGC.WMTS.Version_1_0_0.Operation[]
{
getCapOperation, getTileOperation
};
#endregion
#region Contents
capabilities.Contents = new gView.Framework.OGC.WMTS.Version_1_0_0.ContentsType();
List <gView.Framework.OGC.WMTS.Version_1_0_0.LayerType> layers = new List <gView.Framework.OGC.WMTS.Version_1_0_0.LayerType>();
List <gView.Framework.OGC.WMTS.Version_1_0_0.TileMatrixSet> matrixSets = new List <gView.Framework.OGC.WMTS.Version_1_0_0.TileMatrixSet>();
ISpatialReference sRef4326 = SpatialReference.FromID("epsg:4326");
foreach (var epsg in metadata.EPSGCodes)
{
IEnvelope extent = metadata.GetEPSGEnvelope(epsg);
if (extent == null)
{
Console.WriteLine($"EPSG { epsg }: Envelope not exits");
continue;
}
IPoint origin = metadata.GetOriginUpperLeft(epsg);
if (origin == null)
{
Console.WriteLine($"EPSG { epsg }: Origin not exits");
continue;
}
ISpatialReference sRef = SpatialReference.FromID("epsg:" + epsg);
IEnvelope extent4326 = GeometricTransformerFactory.Transform2D(extent, sRef, sRef4326).Envelope;
if (double.IsInfinity(extent4326.minx))
{
extent4326.minx = -180D;
}
if (double.IsInfinity(extent4326.miny))
{
extent4326.miny = -90D;
}
if (double.IsInfinity(extent4326.maxx))
{
extent4326.maxx = 180D;
}
if (double.IsInfinity(extent4326.maxy))
{
extent4326.maxy = 90D;
}
foreach (string cacheType in new string[] { "classic", "compact" })
{
string epsgPath = _mapServer.TileCachePath + @"/" + MapName(context) + @"/_alllayers/" + (cacheType == "compact" ? @"compact/" : "") +
TileServiceMetadata.EpsgPath(GridOrientation.UpperLeft, epsg);
if (!new DirectoryInfo(epsgPath).Exists)
{
Console.WriteLine($"Path { epsgPath }: not exists");
continue;
}
#region Layer
string layerName = /*Capabilities*/ MapName(context) + " EPSG:" + epsg + " " + cacheType;
string layerId = /*Capabilities*/ MapName(context).ToLower().Replace(" ", "_") + "_" + epsg + "_" + cacheType;
var layer = new gView.Framework.OGC.WMTS.Version_1_0_0.LayerType();
layer.Title = new gView.Framework.OGC.WMTS.Version_1_0_0.LanguageStringType[] { new gView.Framework.OGC.WMTS.Version_1_0_0.LanguageStringType()
{
Value = layerName
} };
layer.Identifier = new gView.Framework.OGC.WMTS.Version_1_0_0.CodeType()
{
Value = layerId
};
List <gView.Framework.OGC.WMTS.Version_1_0_0.Style> styles = new List <Framework.OGC.WMTS.Version_1_0_0.Style>();
//styles.Add(new gView.Framework.OGC.WMTS.Version_1_0_0.Style()
//{
// Title = new gView.Framework.OGC.WMTS.Version_1_0_0.LanguageStringType[] { new gView.Framework.OGC.WMTS.Version_1_0_0.LanguageStringType() { Value = "Default Style" } },
// Identifier = new gView.Framework.OGC.WMTS.Version_1_0_0.CodeType() { Value = "default" }
//});
foreach (FilterImplementations styleVal in Enum.GetValues(typeof(FilterImplementations)))
{
string name = Enum.GetName(typeof(FilterImplementations), styleVal);
styles.Add(new Framework.OGC.WMTS.Version_1_0_0.Style()
{
isDefault = styleVal == FilterImplementations.Default,
Title = new gView.Framework.OGC.WMTS.Version_1_0_0.LanguageStringType[] { new gView.Framework.OGC.WMTS.Version_1_0_0.LanguageStringType()
{
Value = name
} },
Identifier = new gView.Framework.OGC.WMTS.Version_1_0_0.CodeType()
{
Value = name.ToLower()
}
});
}
layer.Style = styles.ToArray();
#region BoundingBox
layer.BoundingBox = new gView.Framework.OGC.WMTS.Version_1_0_0.BoundingBoxType[]
{
new gView.Framework.OGC.WMTS.Version_1_0_0.BoundingBoxType()
{
crs = "urn:ogc:def:crs:EPSG::" + epsg,
LowerCorner = PointToString(extent.LowerLeft, sRef),
UpperCorner = PointToString(extent.UpperRight, sRef)
}
};
layer.WGS84BoundingBox = new gView.Framework.OGC.WMTS.Version_1_0_0.WGS84BoundingBoxType[]
{
new gView.Framework.OGC.WMTS.Version_1_0_0.WGS84BoundingBoxType()
{
crs = "urn:ogc:def:crs:OGC:2:84", // urn:ogc:def:crs:OGC:2:84
LowerCorner = PointToString(extent4326.LowerLeft, /*sRef4326*/ null),
UpperCorner = PointToString(extent4326.UpperRight, /*sRef4326*/ null)
}
};
#endregion
layer.TileMatrixSetLink = new gView.Framework.OGC.WMTS.Version_1_0_0.TileMatrixSetLink[]
{
new gView.Framework.OGC.WMTS.Version_1_0_0.TileMatrixSetLink()
{
TileMatrixSet = layerId + "_default_matrixset"
}
};
List <string> formats = new List <string>();
if (metadata.FormatJpg)
{
formats.Add("image/jpg");
}
if (metadata.FormatPng)
{
formats.Add("image/png");
}
layer.Format = formats.ToArray();
List <Framework.OGC.WMTS.Version_1_0_0.URLTemplateType> resourceURLs = new List <Framework.OGC.WMTS.Version_1_0_0.URLTemplateType>();
if (metadata.FormatJpg)
{
resourceURLs.Add(new Framework.OGC.WMTS.Version_1_0_0.URLTemplateType()
{
resourceType = Framework.OGC.WMTS.Version_1_0_0.URLTemplateTypeResourceType.tile,
format = "image/jpg",
template = restFulUrl + "/" + cacheType + "/ul/" + epsg + "/{Style}/{TileMatrix}/{TileRow}/{TileCol}.jpg"
});
}
if (metadata.FormatPng)
{
resourceURLs.Add(new Framework.OGC.WMTS.Version_1_0_0.URLTemplateType()
{
resourceType = Framework.OGC.WMTS.Version_1_0_0.URLTemplateTypeResourceType.tile,
format = "image/png",
template = restFulUrl + "/" + cacheType + "/ul/" + epsg + "/{Style}/{TileMatrix}/{TileRow}/{TileCol}.png"
});
}
layer.ResourceURL = resourceURLs.ToArray();
layers.Add(layer);
#endregion
#region Matrix Set
double matrixSetWidth = Math.Abs(extent.maxx - origin.X); // extent.Width;
double matrixSetHeight = Math.Abs(origin.Y - extent.miny); // extent.Height;
var matrixSet = new gView.Framework.OGC.WMTS.Version_1_0_0.TileMatrixSet();
matrixSet.Title = new gView.Framework.OGC.WMTS.Version_1_0_0.LanguageStringType[] { new gView.Framework.OGC.WMTS.Version_1_0_0.LanguageStringType()
{
Value = layerName + " Default Matrix Set"
} };
matrixSet.Identifier = new gView.Framework.OGC.WMTS.Version_1_0_0.CodeType()
{
Value = layerId + "_default_matrixset"
};
matrixSet.SupportedCRS = "urn:ogc:def:crs:EPSG::" + epsg;
matrixSet.TileMatrix = new gView.Framework.OGC.WMTS.Version_1_0_0.TileMatrix[metadata.Scales.Count];
#region DPI
double inchMeter = 0.0254; /* 0.0254000508001016;*/
double dpi = inchMeter * 1000D / 0.28D; // wmts 0.28mm -> 1 Pixel;
double dpm = dpi / inchMeter;
#endregion
for (int s = 0, to = metadata.Scales.Count; s < to; s++)
{
string scalePath = _mapServer.TileCachePath + @"/" + MapName(context) + @"/_alllayers/" + (cacheType == "compact" ? @"compact/" : "") +
TileServiceMetadata.ScalePath(GridOrientation.UpperLeft, epsg, metadata.Scales[s]);
if (!new DirectoryInfo(scalePath).Exists)
{
break;
}
double resolution = metadata.Scales[s] / (metadata.Dpi / inchMeter);
matrixSet.TileMatrix[s] = new gView.Framework.OGC.WMTS.Version_1_0_0.TileMatrix();
matrixSet.TileMatrix[s].Identifier = new gView.Framework.OGC.WMTS.Version_1_0_0.CodeType()
{
Value = s.ToString()
};
matrixSet.TileMatrix[s].TopLeftCorner = PointToString(origin, sRef);
matrixSet.TileMatrix[s].TileWidth = metadata.TileWidth.ToString();
matrixSet.TileMatrix[s].TileHeight = metadata.TileHeight.ToString();
double tileWidth = metadata.TileWidth * resolution;
double tileHeight = metadata.TileHeight * resolution;
int matrixWidth = (int)Math.Round(matrixSetWidth / tileWidth + 0.5);
int matrixHeight = (int)Math.Round(matrixSetHeight / tileHeight + 0.5);
matrixSet.TileMatrix[s].MatrixWidth = matrixWidth.ToString();
matrixSet.TileMatrix[s].MatrixHeight = matrixHeight.ToString();
matrixSet.TileMatrix[s].ScaleDenominator = resolution * dpm;
}
matrixSets.Add(matrixSet);
#endregion
}
}
capabilities.Contents.DatasetDescriptionSummary = layers.ToArray();
capabilities.Contents.TileMatrixSet = matrixSets.ToArray();
#endregion
XsdSchemaSerializer <gView.Framework.OGC.WMTS.Version_1_0_0.Capabilities> ser = new XsdSchemaSerializer <gView.Framework.OGC.WMTS.Version_1_0_0.Capabilities>();
string xml = ser.Serialize(capabilities, null);
xml = xml.Replace(@"<ows:DatasetDescriptionSummary xsi:type=""LayerType"">", "<Layer>");
xml = xml.Replace(@"</ows:DatasetDescriptionSummary>", "</Layer>");
context.ServiceRequest.ResponseContentType = "text/xml";
context.ServiceRequest.Response = xml;
}
