public async void FBModelImport()
{
Rootobject result = new Rootobject();
//var allCitiesQuery = DB.Collection("models");
//var docModel = allCitiesQuery.Document("test1");
//Firebase.Firestore.DocumentSnapshot snapshot = await docModel.GetSnapshotAsync();
//if (snapshot.Exists)
// {
// var st = Newtonsoft.Json.JsonConvert.SerializeObject(snapshot.ToDictionary());
// importModel = Newtonsoft.Json.JsonConvert.DeserializeObject<Rootobject>(st);
// CreateMaterials.create(importModel.materials);
// //Create Main Object
// GameObject MainObj = new GameObject(importModel._object.name);
// //Create geometries
// List<GameObject> createdGeom = Geometries.create(importModel.geometries);
// //Create Childrens and assign them to Main Object
// ObjChildrens.create(importModel._object.children, MainObj, createdGeom);
//}
// else
// {
// Debug.Log("Document {0} does not exist!" + snapshot.Id.ToString());
// }
try
{
DocumentReference docRef = DB.Collection("models").Document("test1");
var listener = docRef.Listen(snapshot =>
{
if (snapshot.Exists)
{
var st = Newtonsoft.Json.JsonConvert.SerializeObject(snapshot.ToDictionary());
importModel = Newtonsoft.Json.JsonConvert.DeserializeObject <Rootobject>(st);
//If the element already exists remove it
var gameObjects = SceneManager.GetActiveScene().GetRootGameObjects();
foreach (GameObject go in gameObjects)
{
if (go.name == importModel._object.name)
{
Destroy(go);
}
}
CreateMaterials.create(importModel.materials);
//Create Main Object
//Create main Game object
GameObject MainObj = new GameObject(importModel._object.name);
//Create geometries
List <GameObject> createdGeom = Geometries.create(importModel.geometries);
//Create Childrens and assign them to Main Object
ObjChildrens.create(importModel._object.children, MainObj, createdGeom);
}
});
}
catch
{
}
}
public void TestDefect2Dim()
{
var ambiantSpace = Geometries.GetSpace(CurvatureType.NEGATIVE, 2);
var randomSamples = Simplex.RandomSamples(NUMBER_SAMPLES, 2, ambiantSpace, true, MAX_NORM);
var counter = 0;
foreach (var simplex in randomSamples)
{
foreach (var face in simplex.Faces)
{
var normalVector = VariousHelpers.GetNormalVector(face);
foreach (var dirVector in face.DirectionalVectors)
{
var scalarProduct = dirVector.DotProduct(normalVector);
if (Math.Abs(scalarProduct) >= TOLERANCE)
{
throw new Exception($"Deviation to high for simplex number {counter}");
}
}
counter++;
}
}
}
public void TestNormVectorComputation()
{
for (int iDim = 2; iDim < 10; iDim++)
{
var ambiantSpace = Geometries.GetSpace(CurvatureType.FLAT, iDim);
var randomSamples = Simplex.RandomSamples(NUMBER_SAMPLES, iDim, ambiantSpace, true, MAX_NORM);
var counter = 0;
foreach (var simplex in randomSamples)
{
var normalVectorSum = Vector <double> .Build.DenseOfArray(new double[iDim]);
foreach (var face in simplex.Faces)
{
var normalVector = VariousHelpers.GetNormalVector(face);
face.Integrate(0, true);
var volumeFace = face.Volume;
var normNormalVector = normalVector.L2Norm();
normalVectorSum += volumeFace * normalVector;
}
if (Math.Abs(normalVectorSum.L2Norm()) >= TOLERANCE)
{
throw new Exception($"Deviation to high for simplex number {counter}");
}
counter++;
}
}
}
public (List <Simplex>, List <SimplexComplex>) RandomSamples()
{
var riemannianSpace = Geometries.GetSpace(CurvatureType, Dim);
var randomSimplices = Simplex.RandomSamples(NbSamples, Dim, riemannianSpace, ZeroAmongEdges, MaxNorm);
var randomComplexes = new List <SimplexComplex>();
var counter = 0;
foreach (var randomSimplex in randomSimplices)
{
var stopWatch = new Stopwatch();
stopWatch.Start();
var simplexComplex = new SimplexComplex(randomSimplex);
simplexComplex.Propagate();
if (Integrate)
{
simplexComplex.Integrate(MeshSteps, null, ComputeAnalytical);
}
if (ComputeAngles)
{
simplexComplex.ComputeAngles();
}
counter++;
stopWatch.Stop();
var sampleCreationEventArgs = new SampleCreationEventArgs(counter, NbSamples, stopWatch.Elapsed.TotalSeconds);
OnSampleCreationEvent(sampleCreationEventArgs);
randomComplexes.Add(simplexComplex);
}
return(randomSimplices, randomComplexes);
}
void attributesTable_RowChanged(object sender, System.Data.DataRowChangeEventArgs e)
{
if (e.Action == DataRowAction.Add)
{
Geometries.Add(((FeatureDataRow)e.Row).Geometry);
}
}
private void OnOgrGeometryChanged()
{
_ignoreGeoChanged = true;
_ignoreCoordChanged = true;
Geometries.Clear();
Coordinates.Clear();
if (OgrGeometry != null)
{
var geometryCount = OgrGeometry.GetGeometryCount();
if (geometryCount == 0)
{
var pointCount = OgrGeometry.GetPointCount();
var dimension = OgrGeometry.GetCoordinateDimension();
for (int i = 0; i < pointCount; i++)
{
double[] argout = new double[dimension];
OgrGeometry.GetPoint(i, argout);
Coordinate coordinate = new Coordinate(argout);
Coordinates.Add(coordinate);
}
}
else
{
for (int i = 0; i < geometryCount; i++)
{
var ogrGeometry = OgrGeometry.GetGeometryRef(i);
Geometry geometry = new Geometry(ogrGeometry);
Geometries.Add(geometry);
}
}
}
_ignoreGeoChanged = false;
_ignoreCoordChanged = false;
}
public void TestRelations(string relation)
{
var ambiantSpace = Geometries.GetSpace(CurvatureType.FLAT, 2);
var randomSamples = Simplex.RandomSamples(NUMBER_SAMPLES, 2, ambiantSpace, true, MAX_NORM);
var counter = 0;
var anlgeRelations = GetAnlgeRelations();
foreach (var simplex in randomSamples)
{
foreach (var angleRelation in anlgeRelations)
{
var faceA = simplex.Faces[0];
var faceB = simplex.Faces[1];
var faceC = simplex.Faces[2];
var normVectorA = VariousHelpers.GetNormalVector(faceA);
var normVectorB = VariousHelpers.GetNormalVector(faceB);
var normVectorC = VariousHelpers.GetNormalVector(faceC);
var alpha = Math.PI - VariousHelpers.Angle(normVectorB, normVectorC);
var beta = Math.PI - VariousHelpers.Angle(normVectorA, normVectorC);
var gamma = Math.PI - VariousHelpers.Angle(normVectorA, normVectorB);
var value = angleRelation.Value(alpha, beta, gamma);
if (Math.Abs(value) >= TOLERANCE)
{
throw new Exception($"Deviation to high for simplex number {counter}");
}
}
counter++;
}
}
public List <LineSegment> GetLineSegments()
{
switch (this.Type)
{
case GeometryType.LineString:
return(GetLineSegments(false));
case GeometryType.Polygon:
return(Geometries.SelectMany(i => i.GetLineSegments(true)).ToList());
case GeometryType.MultiLineString:
return(Geometries.SelectMany(i => i.GetLineSegments(false)).ToList());
case GeometryType.MultiPolygon:
return(Geometries.SelectMany(i => i.GetLineSegments()).ToList());
case GeometryType.GeometryCollection:
return(Geometries.SelectMany(i => i.GetLineSegments()).ToList());
case GeometryType.Point:
case GeometryType.MultiPoint:
case GeometryType.CircularString:
case GeometryType.CompoundCurve:
case GeometryType.CurvePolygon:
default:
throw new NotImplementedException();
}
}
public GeoProject shpRead()
{
//IFeatureSet fs = FeatureSet.Open(shppath);
string str = fs.ProjectionString;
ProjectionInfo info = fs.Projection;
project = new GeoProject();
for (int i = 0; i < fs.Features.Count; i++)
{
Geometries geometries = new Geometries();
IList <Coordinate> vertics = fs.Features[i].Coordinates;
GeoPolygon polygon = new GeoPolygon();
int circle = 1;
foreach (Coordinate vertic in vertics)
{
GeoPoint point = new GeoPoint();
point.X = vertic.X;
point.Y = vertic.Y;
if (polygon.Points.Contains(point))
{
polygon.Circle = circle;
geometries.Polygons.Add(polygon);
circle++;
polygon = new GeoPolygon();
}
polygon.Points.Add(point);
}
polygon.Circle = circle;
geometries.Polygons.Add(polygon);
project.Geometries.Add(geometries);
}
return(project);
}
/// <summary>
/// Converts any <see cref="GisSharpBlog.NetTopologySuite.Geometries.Geometry"/> to the correspondant
/// <see cref="SharpMap.Geometries.Geometry"/>.
/// </summary>
public static NTSGeometry ToNTSGeometry(Geometries.Geometry geometry, IGeometryFactory factory)
{
if (geometry == null)
throw new NullReferenceException("geometry");
if (TypeOf(geometry, typeof(Geometries.Point)))
return ToNTSPoint(geometry as Geometries.Point, factory);
if (TypeOf(geometry, typeof (Geometries.LineString)))
return ToNTSLineString(geometry as Geometries.LineString, factory);
if (TypeOf(geometry, typeof (Geometries.Polygon)))
return ToNTSPolygon(geometry as Geometries.Polygon, factory);
if (TypeOf(geometry, typeof (Geometries.MultiPoint)))
return ToNTSMultiPoint(geometry as Geometries.MultiPoint, factory);
if (TypeOf(geometry, typeof (Geometries.MultiLineString)))
return ToNTSMultiLineString(geometry as Geometries.MultiLineString, factory);
if (TypeOf(geometry, typeof (Geometries.MultiPolygon)))
return ToNTSMultiPolygon(geometry as Geometries.MultiPolygon, factory);
if (TypeOf(geometry, typeof (Geometries.GeometryCollection)))
return ToNTSGeometryCollection(geometry as Geometries.GeometryCollection, factory);
var message = String.Format("Type {0} not supported", geometry.GetType().FullName);
throw new NotSupportedException(message);
}
/// <summary>
/// Removes if contained
/// </summary>
/// <param name="geometry"></param>
protected virtual bool Remove(NetTopologySuite.Geometries.Geometry geometry, System.Collections.Generic.IEqualityComparer <NetTopologySuite.Geometries.Geometry> comparer = null)
{
if (IsReadOnly || IsEmpty)
{
return(false);
}
comparer = comparer ?? new Geometry.ExactGeometryComparer();
for (int i = 0; i < Geometries.Length; ++i)
{
if (comparer.Equals(geometry, Geometries[i]))
{
if (geometry is IPolygonal)
{
polygonCount -= geometry.NumGeometries;
}
else if (geometry is ILineal)
{
lineStringCount -= geometry.NumGeometries;
}
else if (geometry is IPuntal)
{
pointCount -= geometry.NumGeometries;
}
if (geometry is ICurvedGeometry)
{
curveCount -= geometry.NumGeometries;
}
Geometries = Geometries.Take(i).Skip(1).Take(int.MaxValue).ToArray();
GeometryChanged();
return(true);
}
}
return(false);
}
/// <summary>
/// Adds to <see cref="Geometries"/>
/// </summary>
/// <param name="geometry"></param>
protected void Add(NetTopologySuite.Geometries.Geometry geometry)
{
if (IsReadOnly)
{
return;
}
if (geometry is IPolygonal)
{
polygonCount += geometry.NumGeometries;
}
else if (geometry is ILineal)
{
lineStringCount += geometry.NumGeometries;
}
else if (geometry is IPuntal)
{
pointCount += geometry.NumGeometries;
}
if (geometry is ICurvedGeometry)
{
curveCount += geometry.NumGeometries;
}
if (IsEmpty)
{
Geometries = new[] { geometry };
}
else
{
Geometries = Geometries.Append(geometry).ToArray();
GeometryChanged();
}
}
public GeoProject shpRead()
{
//IFeatureSet fs = FeatureSet.Open(shppath);
string str = fs.ProjectionString;
ProjectionInfo info = fs.Projection;
project = new GeoProject();
for (int i = 0; i < fs.Features.Count; i++) {
Geometries geometries = new Geometries();
IList<Coordinate> vertics = fs.Features[i].Coordinates;
GeoPolygon polygon = new GeoPolygon();
int circle = 1;
foreach (Coordinate vertic in vertics) {
GeoPoint point = new GeoPoint();
point.X = vertic.X;
point.Y = vertic.Y;
if (polygon.Points.Contains(point)) {
polygon.Circle = circle;
geometries.Polygons.Add(polygon);
circle++;
polygon = new GeoPolygon();
}
polygon.Points.Add(point);
}
polygon.Circle = circle;
geometries.Polygons.Add(polygon);
project.Geometries.Add(geometries);
}
return project;
}
public void TestAngleComputation2Dim()
{
var ambiantSpace = Geometries.GetSpace(CurvatureType.FLAT, 2);
var randomSamples = Simplex.RandomSamples(NUMBER_SAMPLES, 2, ambiantSpace, true, MAX_NORM);
var counter = 0;
foreach (var simplex in randomSamples)
{
var faceA = simplex.Faces[0];
var faceB = simplex.Faces[1];
var faceC = simplex.Faces[2];
var normVectorA = VariousHelpers.GetNormalVector(faceA);
var normVectorB = VariousHelpers.GetNormalVector(faceB);
var normVectorC = VariousHelpers.GetNormalVector(faceC);
var alpha = Math.PI - VariousHelpers.Angle(normVectorB, normVectorC);
var beta = Math.PI - VariousHelpers.Angle(normVectorA, normVectorC);
var gamma = Math.PI - VariousHelpers.Angle(normVectorA, normVectorB);
if (Math.Abs(alpha + beta + gamma - Math.PI) >= TOLERANCE)
{
throw new Exception($"Deviation to high for simplex number {counter}");
}
counter++;
}
}
public GeometryViewModel()
{
Geometries = AUTDSettings.Instance.GeometriesReactive;
Current = new ReactivePropertySlim <GeometrySettingReactive?>();
AddItem = new ReactiveCommand();
RemoveItem = Current.Select(c => c != null).ToReactiveCommand();
UpItem = Current.Select(c => c != null && c.No.Value != 0).ToReactiveCommand();
DownItem = Current.Select(c => c != null && c.No.Value != Geometries.Count - 1).ToReactiveCommand();
AddItem.Subscribe(_ =>
{
var item = new GeometrySettingReactive(Geometries.Count);
Geometries.Add(item);
Current.Value = item;
});
RemoveItem.Subscribe(_ =>
{
if (Current.Value == null)
{
return;
}
var delNo = Current.Value.No.Value;
Geometries.RemoveAt(delNo);
ResetNo();
Current.Value = Geometries.Count > delNo ? Geometries[delNo] : Geometries.Count > 0 ? Geometries[delNo - 1] : null;
});
UpItem.Subscribe(_ =>
{
if (Current.Value == null)
{
return;
}
var cNo = Current.Value.No.Value;
var up = Geometries[cNo - 1];
Geometries.Insert(cNo - 1, Current.Value);
Geometries.RemoveAt(cNo);
Geometries[cNo] = up;
ResetNo();
Current.Value = Geometries[cNo - 1];
});
DownItem.Subscribe(_ =>
{
if (Current.Value == null)
{
return;
}
var cNo = Current.Value.No.Value;
var down = Geometries[cNo + 1];
Geometries.RemoveAt(cNo + 1);
Geometries.Insert(cNo + 1, Current.Value);
Geometries[cNo] = down;
ResetNo();
Current.Value = Geometries[cNo + 1];
});
}
//CONSTRUCTOR
public Design(RadicalComponent component)
{
//Access the component
this.MyComponent = component;
this.Variables = new List <IVariable>();
this.Geometries = new List <IDesignGeometry>();
this.Constraints = new List <Constraint>();
// ADD VARIABLES
//Sliders
foreach (IGH_Param param in MyComponent.Params.Input[2].Sources)
{
SliderVariable s = new SliderVariable(param);
if (s.CurrentValue == 0)
{
if (s.Max >= 0.001)
{
s.UpdateValue(0.001);
}
else
{
s.UpdateValue(-0.001);
}
}
this.Variables.Add(new SliderVariable(param));
}
Grasshopper.Instances.ActiveCanvas.Document.NewSolution(false, Grasshopper.Kernel.GH_SolutionMode.Silent);
//Surfaces
for (int i = 0; i < MyComponent.Params.Input[3].Sources.Count; i++)
{
IGH_Param param = MyComponent.Params.Input[3].Sources[i];
NurbsSurface surf = MyComponent.SrfVariables[i];
Geometries.Add(new DesignSurface(param, surf));
}
//Curves
for (int i = 0; i < MyComponent.Params.Input[4].Sources.Count; i++)
{
IGH_Param param = MyComponent.Params.Input[4].Sources[i];
NurbsCurve curv = MyComponent.CrvVariables[i];
this.Geometries.Add(new DesignCurve(param, curv));
}
// Add geometries to variables list
// not the cleanest way to do it, review code structure
if (Geometries.Any())
{
this.Variables.AddRange(Geometries.Select(x => x.Variables).SelectMany(x => x).ToList());
}
// ADD CONSTRAINTS
for (int i = 0; i < component.Constraints.Count; i++)
{
this.Constraints.Add(new Constraint(MyComponent, Constraint.ConstraintType.morethan, i));
}
MyComponent.numVars = this.Variables.Where(var => var.IsActive).Count();
}
public void Write(Stream stream)
{
// TODO: validate in debug mode that this is producing the current data model. Look at the schema!
stream.WriteBFastHeader(Header);
stream.WriteBFastBody(Header, Names, Sizes, (_stream, index, name, size) =>
{
switch (name)
{
case "meta":
_stream.Write(Meta);
break;
case VimConstants.G3dLegacySchema.Position:
Geometries.ForEach(g => stream.Write(g.Vertices.ToArray()));
break;
case "g3d:vertex:color:0:float32:4":
if (UseColors)
{
Geometries.ForEach(g => stream.Write(g.Colors.ToArray()));
}
break;
case VimConstants.G3dLegacySchema.Index:
for (var i = 0; i < Geometries.Count; ++i)
{
var g = Geometries[i];
var offset = VertexOffsets[i];
stream.Write(g.Indices.Select(idx => idx + offset).ToArray());
}
break;
case VimConstants.G3dLegacySchema.Uv:
Geometries.ForEach(g => stream.Write(g.UVs.ToArray()));
break;
case VimConstants.G3dLegacySchema.MaterialId:
Geometries.ForEach(g => stream.Write(g.MaterialIds.ToArray()));
break;
case VimConstants.G3dLegacySchema.GroupId:
Geometries.ForEach(g => stream.Write(g.FaceGroupIds.ToArray()));
break;
case VimConstants.G3dLegacySchema.IndexOffset:
stream.Write(IndexOffsets);
break;
case VimConstants.G3dLegacySchema.VertexOffset:
stream.Write(VertexOffsets);
break;
default:
throw new Exception($"Not a recognized geometry buffer: {name}");
}
return(size);
});
}
public void Attach(Geometry3D Geometry)
{
if (!Geometries.ContainsKey(Geometry))
{
Geometries.Add(Geometry, Geometry.Name);
Count = Geometries.Count;
}
}
public override bool IsValid()
{
if (Geometries == null)
{
return(false);
}
return(Geometries.Count > 0 && Geometries.All(ls => ls.IsValid()));
}
public void DetachGeometry(Geometry3D Geometry)
{
if (Geometries.ContainsKey(Geometry))
{
Geometries.Remove(Geometry);
Count = Geometries.Count;
}
}
/// <summary>
/// Renders a LineString to the map.
/// </summary>
/// <param name="g">Graphics reference</param>
/// <param name="line">LineString to render</param>
/// <param name="pen">Pen style used for rendering</param>
/// <param name="map">Map reference</param>
public static void DrawLineString(System.Drawing.Graphics g, Geometries.LineString line, System.Drawing.Pen pen, SharpMap.Map map)
{
if (line.Vertices.Count > 1)
{
System.Drawing.Drawing2D.GraphicsPath gp = new System.Drawing.Drawing2D.GraphicsPath();
gp.AddLines(line.TransformToImage(map));
g.DrawPath(pen, gp);
}
}
private void ClearAll()
{
Vertices.Clear();
Normals.Clear();
Colors.Clear();
UV.Clear();
Geometries.Clear();
Materials.Clear();
BoundingBox = new BoundingBox();
}
/// <summary>
/// Converts any <see cref="SharpMap.Geometries.Geometry"/> array to the correspondant
/// <see cref="GisSharpBlog.NetTopologySuite.Geometries.Geometry" /> array.
/// </summary>
public static NTSGeometry[] ToNTSGeometry(Geometries.Geometry[] geometries,
IGeometryFactory factory)
{
NTSGeometry[] converted = new NTSGeometry[geometries.Length];
int index = 0;
foreach (Geometries.Geometry geometry in geometries)
converted[index++] = ToNTSGeometry(geometry, factory);
if ((geometries.Length != converted.Length))
throw new ApplicationException("Conversion error");
return converted;
}
public void TransformSceneInPlace(Func <IMesh, IMesh> meshTransform = null, Func <VimSceneNode, VimSceneNode> nodeTransform = null)
{
if (meshTransform != null)
{
Geometries = Geometries.Select(meshTransform).EvaluateInParallel();
}
if (nodeTransform != null)
{
VimNodes = VimNodes.Select(nodeTransform).EvaluateInParallel();
}
}
public override Geometry Clone()
{
var result = CreateNew();
foreach (var item in Geometries.Select(x => x.Clone()))
{
result.Geometries.Add(item);
}
return(result);
}
/*
* public void AttachRange(List<Node3D> NodeList)
* {
* for (int i = 0; i < NodeList.Count; i++)
* {
* if (!Children.ContainsKey(NodeList[i]))
* {
* Children.Add(NodeList[i], NodeList[i].Name);
* }
* }
* }
*/
public void AttachRange(List <Geometry3D> GeometryList)
{
for (int i = 0; i < GeometryList.Count; i++)
{
if (!Geometries.ContainsKey(GeometryList[i]))
{
Geometries.Add(GeometryList[i], GeometryList[i].Name);
}
}
Count = Geometries.Count;
}
public void RemoveVisual(IDrawingVisual dv)
{
RemoveVisualChild((Visual)dv);
RemoveLogicalChild((Visual)dv);
if (dv is ICADEnitiyVisual)
{
Geometries.Remove((ICADEnitiyVisual)dv);
}
else
{
_tempVisuals.Remove(dv);
}
}
public void AddVisual(IDrawingVisual dv)
{
if (dv is ICADEnitiyVisual)
{
Geometries.Add((ICADEnitiyVisual)dv);
}
else
{
_tempVisuals.Add(dv);
}
AddVisualChild((Visual)dv);
AddLogicalChild((Visual)dv);
}
public IPoint GetLastPoint()
{
if (Points != null)
{
return(Points.Last());
}
else if (Geometries != null)
{
return(Geometries.Last().GetLastPoint());
}
else
{
return(null);
}
}
public bool HasAnyPoint()
{
if (Points != null)
{
return(Points.Length > 0);
}
else if (Geometries != null)
{
return(Geometries.Any(g => g.HasAnyPoint()));
}
else
{
return(false);
}
}
public IPoint[] GetAllPoints()
{
if (Points != null)
{
return(Points);
}
else if (Geometries != null)
{
return(Geometries.SelectMany(i => i.GetAllPoints()).ToArray());
}
else
{
return(null);
}
}
public override bool Equals(object obj, SpatialEqualityOptions options)
{
var other = obj as GeometryCollection;
if (ReferenceEquals(null, other))
{
return(false);
}
if (Geometries.Count != other.Geometries.Count)
{
return(false);
}
return(!Geometries
.Where((t, i) => !t.Equals(other.Geometries[i], options))
.Any());
}
/// <summary>
/// Appends a data set to an existing data set.
/// </summary>
/// <param name="data">Data set to append</param>
public void Append(SpatialDataSet data)
{
if (data != null)
{
BoundingBox = data.BoundingBox.Join(BoundingBox);
Geometries.AddRange(data.Geometries);
if (data.Styles != null && data.Styles.Count > 0)
{
if (Styles == null)
{
Styles = data.Styles;
}
else
{
foreach (var key in data.Styles.Keys)
{
if (!Styles.ContainsKey(key))
{
Styles.Add(key, data.Styles[key]);
}
}
}
}
if (!Metadata.HasMetadata())
{
Metadata = data.Metadata;
}
if (!string.IsNullOrEmpty(data.Error))
{
if (string.IsNullOrEmpty(Error))
{
Error = data.Error;
}
else
{
Error += "\r\n" + data.Error;
}
}
}
}
public static UIElement RenderLabel(Geometries.Point position, LabelStyle labelStyle, IViewport viewport, string labelText)
{
var screenPosition = viewport.WorldToScreen(position);
var windowsPosition = screenPosition.ToXaml();
//set some defaults which should be configurable someday
const double witdhMargin = 3.0;
const double heightMargin = 0.0;
var textblock = new TextBlock
{
Text = labelText,
Foreground = new SolidColorBrush(labelStyle.ForeColor.ToXaml()),
FontFamily = new FontFamily(labelStyle.Font.FontFamily),
FontSize = labelStyle.Font.Size,
Margin = new Thickness(witdhMargin, heightMargin, witdhMargin, heightMargin),
FontWeight = FontWeights.Bold
};
var border = new Border
{
Background = new SolidColorBrush(labelStyle.BackColor == null ? Colors.Transparent : labelStyle.BackColor.Color.ToXaml()),
CornerRadius = new CornerRadius(4),
Child = textblock
};
double textWidth;
double textHeight;
#if NETFX_CORE
DetermineTextWidthAndHeightWindows8(out textWidth, out textHeight, border, textblock);
#elif SILVERLIGHT
DetermineTextWidthAndHeightSilverlight(out textWidth, out textHeight, textblock);
#else // WPF
DetermineTextWidthAndHeightWpf(out textWidth, out textHeight, labelStyle, labelText);
#endif
border.SetValue(Canvas.LeftProperty, windowsPosition.X + labelStyle.Offset.X
- (textWidth + 2 * witdhMargin) * (short)labelStyle.HorizontalAlignment * 0.5f);
border.SetValue(Canvas.TopProperty, windowsPosition.Y + labelStyle.Offset.Y
- (textHeight + 2 * heightMargin) * (short)labelStyle.VerticalAlignment * 0.5f);
return border;
}
public IgesGeneralSymbol(IgesGeneralNote note, IEnumerable <IgesLeader> leaders, IEnumerable <IgesEntity> geometries)
: this()
{
Note = note;
foreach (var leader in leaders)
{
Leaders.Add(leader);
}
foreach (var geometry in geometries)
{
Geometries.Add(geometry);
}
if (Geometries.Count < 1)
{
throw new InvalidOperationException($"At least one geometrical entity must be specified.");
}
}
internal static NTSMultiPoint ToNTSMultiPoint(Geometries.MultiPoint geom,
IGeometryFactory factory)
{
NTSPoint[] points = new NTSPoint[geom.Points.Count];
int index = 0;
foreach (Geometries.Point point in geom.Points)
points[index++] = ToNTSPoint(point, factory);
return factory.CreateMultiPoint(points) as NTSMultiPoint;
}
public static Geometries.BoundingBox MapToWorld(Geometries.BoundingBox box, IViewport view)
{
Geometries.Point lowerLeft = view.ScreenToWorld(box.BottomLeft);
Geometries.Point upperRight = view.ScreenToWorld(box.TopRight);
return new Geometries.BoundingBox(lowerLeft, upperRight);
}
public void ZoomToBox(Geometries.Point beginPoint, Geometries.Point endPoint)
{
double x, y, resolution;
var width = Math.Abs(endPoint.X - beginPoint.X);
var height = Math.Abs(endPoint.Y - beginPoint.Y);
if (width <= 0) return;
if (height <= 0) return;
ZoomHelper.ZoomToBoudingbox(beginPoint.X, beginPoint.Y, endPoint.X, endPoint.Y, ActualWidth, out x, out y, out resolution);
resolution = ZoomHelper.ClipToExtremes(map.Resolutions, resolution);
viewport.Center = new Geometries.Point(x, y);
viewport.Resolution = resolution;
toResolution = resolution;
map.ViewChanged(true, viewport.Extent, viewport.Resolution);
OnViewChanged(true, true);
RefreshGraphics();
ClearBBoxDrawing();
}
internal static Polygon ToNTSPolygon(Geometries.Polygon polygon,
GeometryFactory factory)
{
LinearRing shell = ToNTSLinearRing(polygon.ExteriorRing, factory);
LinearRing[] holes = new LinearRing[polygon.InteriorRings.Count];
int index = 0;
foreach (Geometries.LinearRing hole in polygon.InteriorRings)
holes[index++] = ToNTSLinearRing(hole, factory);
return factory.CreatePolygon(shell, holes) as Polygon;
}
public Geometries.BoundingBox Transfrom(int fromSRID, int toSRID, Geometries.BoundingBox boundingBox)
{
throw new NotImplementedException();
}
/// <summary>
/// Renders a multipolygon byt rendering each polygon in the collection by calling DrawPolygon.
/// </summary>
/// <param name="g">Graphics reference</param>
/// <param name="pols">MultiPolygon to render</param>
/// <param name="brush">Brush used for filling (null or transparent for no filling)</param>
/// <param name="pen">Outline pen style (null if no outline)</param>
/// <param name="clip">Specifies whether polygon clipping should be applied</param>
/// <param name="map">Map reference</param>
public static void DrawMultiPolygon(System.Drawing.Graphics g, Geometries.MultiPolygon pols, System.Drawing.Brush brush, System.Drawing.Pen pen, bool clip, SharpMap.Map map)
{
for (int i = 0; i < pols.Polygons.Count; i++)
DrawPolygon(g, pols.Polygons[i], brush, pen, clip, map);
}
/// <summary>
/// Renders a <see cref="SharpMap.Geometries.MultiPoint"/> to the map.
/// </summary>
/// <param name="g">Graphics reference</param>
/// <param name="points">MultiPoint to render</param>
/// <param name="symbol">Symbol to place over point</param>
/// <param name="symbolscale">The amount that the symbol should be scaled. A scale of '1' equals to no scaling</param>
/// <param name="offset">Symbol offset af scale=1</param>
/// <param name="rotation">Symbol rotation in degrees</param>
/// <param name="map">Map reference</param>
public static void DrawMultiPoint(System.Drawing.Graphics g, Geometries.MultiPoint points, System.Drawing.Bitmap symbol, float symbolscale, System.Drawing.PointF offset, float rotation, SharpMap.Map map)
{
for (int i = 0; i < points.Points.Count; i++)
DrawPoint(g, points.Points[i], symbol, symbolscale, offset, rotation, map);
}
internal static NTSMultiLineString ToNTSMultiLineString(Geometries.MultiLineString geom,
IGeometryFactory factory)
{
NTSLineString[] lstrings = new NTSLineString[geom.LineStrings.Count];
int index = 0;
foreach (Geometries.LineString lstring in geom.LineStrings)
lstrings[index++] = ToNTSLineString(lstring, factory);
return factory.CreateMultiLineString(lstrings) as NTSMultiLineString;
}
internal static NTSMultiPolygon ToNTSMultiPolygon(Geometries.MultiPolygon geom,
IGeometryFactory factory)
{
NTSPolygon[] polygons = new NTSPolygon[geom.Polygons.Count];
int index = 0;
foreach (Geometries.Polygon polygon in geom.Polygons)
polygons[index++] = ToNTSPolygon(polygon, factory);
return factory.CreateMultiPolygon(polygons) as NTSMultiPolygon;
}
internal static NTSGeometryCollection ToNTSGeometryCollection(Geometries.GeometryCollection geom,
IGeometryFactory factory)
{
NTSGeometry[] geometries = new NTSGeometry[geom.Collection.Count];
int index = 0;
foreach (Geometries.Geometry geometry in geom.Collection)
geometries[index++] = ToNTSGeometry(geometry, factory);
return factory.CreateGeometryCollection(geometries) as NTSGeometryCollection;
}
private static bool TypeOf(Geometries.Geometry geometry, Type type)
{
if (geometry == null)
throw new ArgumentNullException("geometry");
if (type == null)
throw new ArgumentNullException("type");
return geometry.GetType() == type;
}
private void ExecuteIntersectionQuery(Geometries.Point pt, FeatureDataSet ds)
{
if (CoordinateTransformation != null)
{
#if !DotSpatialProjections
CoordinateTransformation.MathTransform.Invert();
pt = GeometryTransform.TransformPoint(pt, CoordinateTransformation.MathTransform);
CoordinateTransformation.MathTransform.Invert();
#else
pt = GeometryTransform.TransformPoint(pt, CoordinateTransformation.Target, CoordinateTransformation.Source);
#endif
}
//Setup resulting Table
FeatureDataTable dt = new FeatureDataTable();
dt.Columns.Add("Ordinate X", typeof(Double));
dt.Columns.Add("Ordinate Y", typeof(Double));
for (int i = 1; i <= Bands; i++)
dt.Columns.Add(string.Format("Value Band {0}", i), typeof(Double));
//Get location on raster
Double[] buffer = new double[1];
Int32[] bandMap = new int[Bands];
for (int i = 1; i <= Bands; i++) bandMap[i - 1] = i;
Geometries.Point imgPt = _geoTransform.GroundToImage(pt);
Int32 x = Convert.ToInt32(imgPt.X);
Int32 y = Convert.ToInt32(imgPt.Y);
//Test if raster ordinates are within bounds
if (x < 0) return;
if (y < 0) return;
if (x >= _imagesize.Width) return;
if (y >= _imagesize.Height) return;
//Create new row, add ordinates and location geometry
FeatureDataRow dr = dt.NewRow();
dr.Geometry = pt;
dr[0] = pt.X;
dr[1] = pt.Y;
//Add data from raster
for (int i = 1; i <= Bands; i++)
{
Band band = _gdalDataset.GetRasterBand(i);
//DataType dtype = band.DataType;
CPLErr res = band.ReadRaster(x, y, 1, 1, buffer, 1, 1, 0, 0);
if (res == CPLErr.CE_None)
{
dr[1 + i] = buffer[0];
}
else
{
dr[1 + i] = Double.NaN;
}
}
//Add new row to table
dt.Rows.Add(dr);
//Add table to dataset
ds.Tables.Add(dt);
}
//end of windows phone support
private void PanAndZoom(Geometries.Point current, Geometries.Point previous, double deltaScale)
{
var diffX = previous.X - current.X;
var diffY = previous.Y - current.Y;
var newX = viewport.CenterX + diffX;
var newY = viewport.CenterY + diffY;
var zoomCorrectionX = (1 - deltaScale) * (current.X - viewport.CenterX);
var zoomCorrectionY = (1 - deltaScale) * (current.Y - viewport.CenterY);
viewport.Resolution = viewport.Resolution / deltaScale;
viewport.Center = new Geometries.Point(newX - zoomCorrectionX, newY - zoomCorrectionY);
}
/// <summary>
/// Renders a MultiLineString to the map.
/// </summary>
/// <param name="g">Graphics reference</param>
/// <param name="lines">MultiLineString to be rendered</param>
/// <param name="pen">Pen style used for rendering</param>
/// <param name="map">Map reference</param>
public static void DrawMultiLineString(System.Drawing.Graphics g, Geometries.MultiLineString lines, System.Drawing.Pen pen, SharpMap.Map map)
{
for (int i = 0; i < lines.LineStrings.Count; i++)
DrawLineString(g, lines.LineStrings[i], pen, map);
}
internal static NTSPolygon ToNTSPolygon(Geometries.Polygon geom,
IGeometryFactory factory)
{
NTSLinearRing shell = ToNTSLinearRing(geom.ExteriorRing, factory);
NTSLinearRing[] holes = new NTSLinearRing[geom.InteriorRings.Count];
int index = 0;
foreach (Geometries.LinearRing hole in geom.InteriorRings)
holes[index++] = ToNTSLinearRing(hole, factory);
return factory.CreatePolygon(shell, holes) as NTSPolygon;
}
/// <summary>
/// Converts any <see cref=GisSharpBlog.NetTopologySuite.Geometries.Geometry"/> to the correspondant
/// <see cref="SharpMap.Geometries.Geometry"/>.
/// </summary>
/// <param name="geometry"></param>
/// <returns></returns>
public static Geometry ToNTSGeometry(Geometries.Geometry geometry,
GeometryFactory factory)
{
if (geometry == null)
throw new NullReferenceException("geometry");
if (geometry.GetType() == typeof (Point))
return ToNTSPoint(geometry as Point, factory);
else if (geometry.GetType() == typeof (Geometries.LineString))
return ToNTSLineString(geometry as Geometries.LineString, factory);
else if (geometry.GetType() == typeof (Geometries.Polygon))
return ToNTSPolygon(geometry as Geometries.Polygon, factory);
else if (geometry.GetType() == typeof (Geometries.MultiPoint))
return ToNTSMultiPoint(geometry as Geometries.MultiPoint, factory);
else if (geometry.GetType() == typeof (Geometries.MultiLineString))
return ToNTSMultiLineString(geometry as Geometries.MultiLineString, factory);
else if (geometry.GetType() == typeof (Geometries.MultiPolygon))
return ToNTSMultiPolygon(geometry as Geometries.MultiPolygon, factory);
else if (geometry.GetType() == typeof (Geometries.GeometryCollection))
return ToNTSGeometryCollection(geometry as Geometries.GeometryCollection, factory);
else throw new NotSupportedException("Type " + geometry.GetType().FullName + " not supported");
}
private static CGRect RoundToPixel(Geometries.Point min, Geometries.Point max)
{
// To get seamless aligning you need to round the
// corner coordinates to pixel. The new width and
// height will be a result of that.
var x = Math.Round(min.X);
var y = Math.Round(min.Y);
var width = Math.Round(max.X) - Math.Round(min.X);
var height = Math.Round(max.Y) - Math.Round(min.Y);
return new CGRect((float)x, (float)y, (float)width, (float)height);
}
public Geometries.Geometry Transform(int fromSRID, int toSRID, Geometries.Geometry geometry)
{
throw new NotImplementedException();
}
internal static NTSLinearRing ToNTSLinearRing(Geometries.LinearRing geom,
IGeometryFactory factory)
{
NTSCoordinate[] coordinates = new NTSCoordinate[geom.NumPoints];
int index = 0;
foreach (Geometries.Point point in geom.Vertices)
coordinates[index++] = ToNTSCoordinate(point, factory);
return factory.CreateLinearRing(coordinates) as NTSLinearRing;
}
/// <summary>
/// 获取WKT
/// </summary>
/// <param name="geometries">地块</param>
/// <returns>地块WKT</returns>
private static string getWkt(Geometries geometries)
{
string wkt = "";
return wkt;
}
internal static NTSPoint ToNTSPoint(Geometries.Point point, IGeometryFactory factory)
{
return factory.CreatePoint(ToNTSCoordinate(point, factory));
}
internal static NTSCoordinate ToNTSCoordinate(Geometries.Point geom, IGeometryFactory factory)
{
return new Coordinate(geom.X, geom.Y);
}
public void DrawGeometry(Geometries.IGeometry geometry)
{
throw new NotImplementedException();
}
private Bitmap GeneratePartialBitmap(Geometries.Point center, XPosition xPos, YPosition yPos)
{
double x = center.X, y = center.Y;
switch (xPos)
{
case XPosition.Right:
x += m_Map.Envelope.Width;
break;
case XPosition.Left:
x -= m_Map.Envelope.Width;
break;
}
switch (yPos)
{
case YPosition.Top:
y += m_Map.Envelope.Height;
break;
case YPosition.Bottom:
y -= m_Map.Envelope.Height;
break;
}
m_Map.Center = new Geometries.Point(x, y);
return m_Map.GetMap() as Bitmap;
}
private void GetBounds(Geometries.Point p1, Geometries.Point p2,
out Geometries.Point lowerLeft, out Geometries.Point upperRight)
{
lowerLeft = new Geometries.Point(Math.Min(p1.X, p2.X), Math.Min(p1.Y, p2.Y));
upperRight = new Geometries.Point(Math.Max(p1.X, p2.X), Math.Max(p1.Y, p2.Y));
System.Diagnostics.Debug.WriteLine("p1: " + p1);
System.Diagnostics.Debug.WriteLine("p2: " + p2);
System.Diagnostics.Debug.WriteLine("lowerLeft: " + lowerLeft);
System.Diagnostics.Debug.WriteLine("upperRight: " + upperRight);
}
