public bool InitializeContributing(bool parity, PolygonType type)
{
if (type == PolygonType.SUBJECT)
{
if (parity == true)
{
return(m_sParityForContribution);
}
else
{
return(!m_sParityForContribution);
}
}
else
{
if (parity == true)
{
return(m_cParityForContribution);
}
else
{
return(!m_cParityForContribution);
}
}
}
public static PolygonType ToGmlPolygon(this Polygon polygon)
{
PolygonType gmlPolygon = new PolygonType();
if (polygon.Coordinates.Count > 0)
{
gmlPolygon.exterior = new AbstractRingPropertyType();
if (!polygon.Coordinates.Any(ls => !ls.IsClosed()))
{
polygon = ClosePolygon(polygon);
}
gmlPolygon.exterior.Item = ToGmlLinearRing(polygon.Coordinates[0]);
if (polygon.Coordinates.Count > 1)
{
var interiors = new List <AbstractRingPropertyType>();
foreach (var lineString in polygon.Coordinates.Take(1))
{
var interior = new AbstractRingPropertyType();
interior.Item = ToGmlLinearRing(lineString);
interiors.Add(interior);
}
gmlPolygon.interior = interiors.ToArray();
}
}
return(gmlPolygon);
}
static void Main(string[] args)
{
//Point p1 = new Point() { X = 0, Y = 1 };
//Point p2 = new Point() { X = 1, Y = 0 };
Point p3 = new Point() { X = 0, Y = -1 };
Point p4 = new Point() { X = 1, Y = -1 };
Point p5 = new Point() { X = 2, Y = -1 };
//Point p6 = new Point() { X = 2, Y = 0 };
//Point p7 = new Point() { X = 2, Y = 1 };
//Point p1 = new Point() { X = 0, Y = 1 };
//Point p2 = new Point() { X = 1, Y = 0 };
//Point p3 = new Point() { X = 0, Y = -1 };
//Point p4 = new Point() { X = -1, Y = -1 };
//Point p5 = new Point() { X = -2, Y = -1 };
//Point p6 = new Point() { X = -2, Y = 0 };
//Point p7 = new Point() { X = -2, Y = 1 };
List<Point> points = new List<Point>();
//double result = cal(p3, p2, p1);
//points.Add(p1);
//points.Add(p2);
points.Add(p3);
points.Add(p4);
points.Add(p5);
//points.Add(p6);
//points.Add(p7);
ClockDirection vDirection = Polygon.CalculateClockDirection(points, false);
PolygonType type = Polygon.CalculatePolygonType(points, false);
bool flag = Polygon.IsPolyClockwise(points);
}
void ProcessSegment(Segment segment, PolygonType polygonType)
{
if (Misc.PointEquals(segment.start, segment.end))
{
return;
}
SweepEvent e1 = new SweepEvent(segment.start, true, polygonType);
SweepEvent e2 = new SweepEvent(segment.end, true, polygonType, e1);
e1.otherSE = e2;
if (e1.p.x < e2.p.x)
{
e2.isLeft = false;
}
else if (e1.p.x > e2.p.x)
{
e1.isLeft = false;
}
else if (e1.p.y < e2.p.y) // the segment isLeft vertical. The bottom endpoint isLeft the isLeft endpoint
{
e2.isLeft = false;
}
else
{
e1.isLeft = false;
}
// Pushing it so the que is sorted from left to right, with object on the left
// having the highest priority.
eventQueue.Enqueue(e1);
eventQueue.Enqueue(e2);
}
public static PolygonType ToGmlPolygon(this Polygon poly)
{
Polygon polygon = poly;
PolygonType gmlPolygon = new PolygonType();
if (polygon.Coordinates.Count > 0)
{
var exterior = new AbstractRingPropertyType();
gmlPolygon.Item = exterior;
gmlPolygon.ItemElementName = ItemChoiceType5.exterior;
if (!polygon.Coordinates.Any(ls => !ls.IsClosed()))
{
polygon = ClosePolygon(polygon);
}
exterior.Item = ToGmlLinearRing(polygon.Coordinates[0]);
if (polygon.Coordinates.Count > 1)
{
var interiors = new List <AbstractRingPropertyType>();
foreach (var lineString in polygon.Coordinates.Skip(1))
{
var interior = new AbstractRingPropertyType();
interior.Item = ToGmlLinearRing(lineString);
interiors.Add(interior);
}
gmlPolygon.Items1 = interiors.ToArray();
gmlPolygon.Items1ElementName = interiors.Select <AbstractRingPropertyType, Items1ChoiceType3>(int1 => Items1ChoiceType3.interior).ToArray();
}
}
return(gmlPolygon);
}
public bool InitializeContributing(bool parity, PolygonType type)
{
if (type == PolygonType.SUBJECT)
{
if (parity == true)
{
return m_sParityForContribution;
}
else
{
return !m_sParityForContribution;
}
}
else
{
if (parity == true)
{
return m_cParityForContribution;
}
else
{
return !m_cParityForContribution;
}
}
}
public override int GetHashCode()
{
unchecked
{
var hashCode = StartUtc.GetHashCode();
hashCode = (hashCode * 397) ^ EndUtc.GetHashCode();
hashCode = (hashCode * 397) ^ (DateRangeType != null ? DateRangeType.GetHashCode() : 397);
hashCode = (hashCode * 397) ^ (DesignUid != null ? DesignUid.GetHashCode() : 397);
hashCode = (hashCode * 397) ^ (DesignFileName != null ? DesignFileName.GetHashCode() : 397);
hashCode = (hashCode * 397) ^ (ContributingMachines != null ? ContributingMachines.GetListHashCode() : 397);
hashCode = (hashCode * 397) ^ (OnMachineDesignId != null ? OnMachineDesignId.GetHashCode() : 397);
hashCode = (hashCode * 397) ^ (OnMachineDesignName != null ? OnMachineDesignName.GetHashCode() : 397);
hashCode = (hashCode * 397) ^ (ElevationType != null ? ElevationType.GetHashCode() : 397);
hashCode = (hashCode * 397) ^ (VibeStateOn != null ? VibeStateOn.GetHashCode() : 397);
hashCode = (hashCode * 397) ^ (PolygonUid != null ? PolygonUid.GetHashCode() : 397);
hashCode = (hashCode * 397) ^ (PolygonName != null ? PolygonName.GetHashCode() : 397);
hashCode = (hashCode * 397) ^ (PolygonLL != null ? PolygonLL.GetListHashCode() : 397);
hashCode = (hashCode * 397) ^ (PolygonType != null ? PolygonType.GetHashCode() : 397);
hashCode = (hashCode * 397) ^ (ForwardDirection != null ? ForwardDirection.GetHashCode() : 397);
hashCode = (hashCode * 397) ^ (LayerNumber != null ? LayerNumber.GetHashCode() : 397);
hashCode = (hashCode * 397) ^ (AlignmentUid != null ? AlignmentUid.GetHashCode() : 397);
hashCode = (hashCode * 397) ^ (AlignmentFileName != null ? AlignmentFileName.GetHashCode() : 397);
hashCode = (hashCode * 397) ^ (StartStation != null ? StartStation.GetHashCode() : 397);
hashCode = (hashCode * 397) ^ (EndStation != null ? EndStation.GetHashCode() : 397);
hashCode = (hashCode * 397) ^ (LeftOffset != null ? LeftOffset.GetHashCode() : 397);
hashCode = (hashCode * 397) ^ (RightOffset != null ? RightOffset.GetHashCode() : 397);
hashCode = (hashCode * 397) ^ (AsAtDate != null ? AsAtDate.GetHashCode() : 397);
hashCode = (hashCode * 397) ^ (AutomaticsType != null ? AutomaticsType.GetHashCode() : 397);
hashCode = (hashCode * 397) ^ (TemperatureRangeMin != null ? TemperatureRangeMin.GetHashCode() : 397);
hashCode = (hashCode * 397) ^ (TemperatureRangeMax != null ? TemperatureRangeMax.GetHashCode() : 397);
hashCode = (hashCode * 397) ^ (PassCountRangeMin != null ? PassCountRangeMin.GetHashCode() : 397);
hashCode = (hashCode * 397) ^ (PassCountRangeMax != null ? PassCountRangeMax.GetHashCode() : 397);
return(hashCode);
}
}
public Nominatim(FormatType format, PolygonType polygon, AddressDetailsType addressDetail)
{
_format = format;
_polygon = polygon;
_addressDetail = addressDetail;
_search = _searchUrl + "format=" + format.ToString() + "&polygon=" + (int)polygon + "&addressdetails=" + (int)addressDetail + "&q=";
}
public static PolygonType ToGmlPolygon(this Polygon polygon)
{
PolygonType gmlPolygon = new PolygonType();
if (polygon.LineStrings.Count > 0)
{
gmlPolygon.exterior = new AbstractRingPropertyType();
if (!polygon.LineStrings[0].IsClosed())
{
polygon.LineStrings[0].Positions.Add(polygon.LineStrings[0].Positions[0]);
}
gmlPolygon.exterior.Item = ToGmlLinearRing(polygon.LineStrings[0]);
if (polygon.LineStrings.Count > 1)
{
var interiors = new List <AbstractRingPropertyType>();
foreach (var lineString in polygon.LineStrings.Take(1))
{
var interior = new AbstractRingPropertyType();
if (!lineString.IsClosed())
{
lineString.Positions.Add(lineString.Positions[0]);
}
interior.Item = ToGmlLinearRing(lineString);
interiors.Add(interior);
}
gmlPolygon.interior = interiors.ToArray();
}
}
return(gmlPolygon);
}
public Polygon(PolygonType PolyType, Vector3[] Normals, Vector2[] TexCoords, Vector3[] Vertex)
{
this.PolyType = PolyType;
this.Normals = Normals;
this.TexCoords = TexCoords;
this.Vertex = Vertex;
}
public Polygon(PolygonType PolyType, Vector3[] Normals, Vector2[] TexCoords, Vector3[] Vertex)
{
this.PolyType = PolyType;
this.Normals = Normals;
this.TexCoords = TexCoords;
this.Vertex = Vertex;
}
/// <summary>
/// Creates the events for a segment.
/// </summary>
/// <param name="segment">A list consisting of two points defining an edge</param>
/// <param name="polygonType"></param>
/// <param name="list">The list to add the events to</param>
private void CreateEvents(IList <Vector2D> segment, PolygonType polygonType,
ICollection <SweepEvent> list)
{
var point1 = segment[0];
var point2 = segment[1];
var event1 = new SweepEvent(point1, false, null, polygonType);
var event2 = new SweepEvent(point2, false, event1, polygonType);
event1.OtherEvent = event2;
if (point1.Equals(point2))
{
// 0-length segments are irrelevant for us since they will never result in intersections
return;
}
// The segment could be ordered the wrong way around, so we need to set the IsStart field properly
if (SweepEvent.CompareTo(event1, event2) > 0)
{
event2.IsStart = true;
}
else
{
event1.IsStart = true;
}
list.Add(event1);
list.Add(event2);
}
public static PolygonType ToGmlPolygon(this Polygon polygon)
{
PolygonType gmlPolygon = new PolygonType();
if (polygon.LineStrings.Count > 0)
{
var exterior = new AbstractRingPropertyType();
gmlPolygon.Item = exterior;
gmlPolygon.ItemElementName = ItemChoiceType5.exterior;
if (!polygon.LineStrings[0].IsClosed())
{
polygon.LineStrings[0].Positions.Add(polygon.LineStrings[0].Positions[0]);
}
exterior.Item = ToGmlLinearRing(polygon.LineStrings[0]);
if (polygon.LineStrings.Count > 1)
{
var interiors = new List <AbstractRingPropertyType>();
foreach (var lineString in polygon.LineStrings.Take(1))
{
var interior = new AbstractRingPropertyType();
if (!lineString.IsClosed())
{
lineString.Positions.Add(lineString.Positions[0]);
}
exterior.Item = ToGmlLinearRing(lineString);
interiors.Add(interior);
}
gmlPolygon.Items1 = interiors.ToArray();
gmlPolygon.Items1ElementName = interiors.Select <AbstractRingPropertyType, Items1ChoiceType3>(int1 => Items1ChoiceType3.interior).ToArray();
}
}
return(gmlPolygon);
}
private void AddNewEvent(gEdge edge, PolygonType polType = PolygonType.None)
{
SweepEvent swStart = new SweepEvent(edge.StartVertex, edge)
{
Label = SweepEventLabel.Normal
};
SweepEvent swEnd = new SweepEvent(edge.EndVertex, edge)
{
Label = SweepEventLabel.Normal
};
swStart.Pair = swEnd;
swEnd.Pair = swStart;
swStart.IsLeft = swStart < swEnd;
swEnd.IsLeft = !swStart.IsLeft;
if (polType != PolygonType.None)
{
swStart.polygonType = polType;
swEnd.polygonType = polType;
}
eventsList.AddItemSorted(swStart);
eventsList.AddItemSorted(swEnd);
}
private Geometry GetPolygon(MultiSurfaceType multi)
{
var p = new Polygon[multi.SurfaceMemberItems.Count];
int npoly = 0;
foreach (SurfacePropertyType member in multi.SurfaceMemberItems)
{
LinearRing shell = null;
PolygonType sur = ExtractShellPolygon(ref shell, member);
if (sur.Interior.Count == 0 && shell != null)
{
p[npoly] = new Polygon(shell);
}
else
{
var holes = new LinearRing[sur.Interior.Count];
ExtractInteriorPolygon(holes, sur);
p[npoly] = new Polygon(shell, holes);
}
npoly++;
}
return(new MultiPolygon(p));
}
public PolygonDatabase(string fileName, PolygonType type, Resolution resolution, IDictionary <int, IPolygon <THeader, TPoint> > polygons)
{
this.FileName = fileName;
this.PolygonType = type;
this.Resolution = resolution;
this.Polygons = polygons;
}
public SweepEvent(Point p, bool isLeft, PolygonType polygonType, SweepEvent otherSweepEvent, EdgeType edgeType)
{
this.p = p;
this.isLeft = isLeft;
this.polygonType = polygonType;
this.otherSE = otherSweepEvent;
this.edgeType = edgeType;
}
public Polygon(PolygonType PolyType, Vector3[] Vertex, Vector3[] Normals, Vector2[] TexCoords, Color[] Colors = null)
{
this.PolyType = PolyType;
this.Normals = Normals;
this.TexCoords = TexCoords;
this.Vertex = Vertex;
this.Colors = Colors;
}
public SweepEvent(Point p, bool isLeft, PolygonType polygonType, SweepEvent otherSweepEvent, EdgeType edgeType)
{
this.p = p;
this.isLeft = isLeft;
this.polygonType = polygonType;
this.otherSE = otherSweepEvent;
this.edgeType = edgeType;
}
public static string Material(Category category, PolygonType pType)
{
if (category == Category.sticker)
{
return(Sticker_Material_Dir);
}
return(GetPath(MATERIAL_NAME, category, pType));
}
private Kml2SqlConfig GetConfig(string tableName, PolygonType geoType)
{
return(new Kml2SqlConfig()
{
GeoType = geoType,
TableName = _tablePrefix + tableName,
FixPolygons = true,
});
}
// create a new polygon with a list of points (which won't change)
public Polygon(List<PointF> ptlist)
{
PolyClose(ptlist); // make sure the polygon is closed by duplicating the first point to the end, if necessary
PtList = ptlist;
PtListOpen = new List<PointF>(PtList);
PtListOpen.RemoveAt(PtList.Count - 1); // remove the last point, which is a duplicate of the first
Area = PolyArea(PtList);
Type = PolyType(PtList, Area);
}
// create a new polygon with a list of points (which won't change)
public Polygon(List <Vector2D> ptlist)
{
PolyClose(ptlist); // make sure the polygon is closed by duplicating the first point to the end, if necessary
PtList = ptlist;
PtListOpen = new List <Vector2D>(PtList);
PtListOpen.RemoveAt(PtList.Count - 1); // remove the last point, which is a duplicate of the first
Area = PolyArea(PtList);
Type = PolyType(PtList, Area);
}
// create a new polygon with a list of points (which won't change)
public PolygonData(List<PointF> ptlist) {
RemoveDoublePoints(ptlist); // make sure there are no two points with the same position
PolyClose(ptlist); // make sure the polygon is closed by duplicating the first point to the end, if necessary
PtList = ptlist;
PtListOpen = new List<PointF>(PtList);
PtListOpen.RemoveAt(PtList.Count - 1); // remove the last point, which is a duplicate of the first
Area = PolyArea(PtList);
Type = PolyType(PtList, Area);
}
public static string Thumb(Category category, PolygonType pType)
{
string path = category == Category.sticker ? Sticker_Texture_Dir : GetPath(THUMB_NAME, category, pType);
#if BLOCK_EDITOR
path = path.Replace("Assets/BlockRes", "block_thumbs");
#endif
return(path);
}
public override string ToString()
{
return(string.Format(
"{0} ({1}) S:[{2} - {3}] ({4}) ({5})",
Point, IsStart ? "left" : "right", Point, OtherEvent.Point,
PolygonType.ToString().ToUpper(),
EdgeType.ToString().ToUpper()
));
}
private void Upload(string fileName, string tableName, PolygonType geoType)
{
using (SqlConnection connection = new SqlConnection(connectionString))
{
connection.Open();
Kml2SqlConfig config = GetConfig(tableName, geoType);
var uploader = new Uploader(fileName, config);
uploader.Upload(connection, true);
}
}
// create a new polygon with a list of points (which won't change)
public PolygonData(List <PointF> ptlist)
{
RemoveDoublePoints(ptlist); // make sure there are no two points with the same position
PolyClose(ptlist); // make sure the polygon is closed by duplicating the first point to the end, if necessary
PtList = ptlist;
PtListOpen = new List <PointF>(PtList);
PtListOpen.RemoveAt(PtList.Count - 1); // remove the last point, which is a duplicate of the first
Area = PolyArea(PtList);
Type = PolyType(PtList, Area);
}
public override int GetHashCode()
{
var hashCode = 1482638751;
hashCode = hashCode * -1521134295 + EqualityComparer <string> .Default.GetHashCode(TexturePath);
hashCode = hashCode * -1521134295 + PolygonType.GetHashCode();
hashCode = hashCode * -1521134295 + TransVal.GetHashCode();
return(hashCode);
}
/*****************************************
* To check vertices make a clock-wise polygon or
* count clockwise polygon
*
* Restriction: the polygon is not self intersecting
* Ref: www.swin.edu.au/astronomy/pbourke/
* geometry/clockwise/index.html
*****************************************/
public PolygonDirection VerticesDirection()
{
int nCount = 0, j = 0, k = 0;
decimal area = 0;
int nVertices = m_aVertices.Length;
PolygonType pType = this.GetPolygonType();
//Calculation Explanation:
//http://local.wasp.uwa.edu.au/~pbourke/geometry/clockwise/index.html
//Calculation for CONVEX (simple)
if (pType == PolygonType.Convex)
{
double crossProduct = (m_aVertices[1].X - m_aVertices[0].X)
* (m_aVertices[2].Y - m_aVertices[1].Y);
crossProduct = crossProduct - (
(m_aVertices[1].Y - m_aVertices[0].Y)
* (m_aVertices[2].X - m_aVertices[1].X));
if (crossProduct > 0)
{
return(PolygonDirection.Count_Clockwise);
}
else if (crossProduct < 0)
{
return(PolygonDirection.Clockwise);
}
else
{
return(PolygonDirection.Unknown);
}
}
else
{
for (int i = 0; i < nVertices - 1; i++)
{
j = (i + 1);
area = area + Convert.ToDecimal((m_aVertices[i].X * m_aVertices[j].Y) - (m_aVertices[j].X * m_aVertices[i].Y));
}
area = area + Convert.ToDecimal((m_aVertices[nVertices - 1].X * m_aVertices[0].Y) - (m_aVertices[0].X * m_aVertices[nVertices - 1].Y));
if (area > 0)
{
return(PolygonDirection.Count_Clockwise);
}
else if (area < 0)
{
return(PolygonDirection.Clockwise);
}
else
{
return(PolygonDirection.Unknown);
}
}
}
public SceneObjectBuilder StartSimpleSprite(float z, TextureInfo sprite, Color color)
{
this.applyPolygonData();
this.currentPolygonType = PolygonType.Sprite;
this.vertexData[z] = new List <float>(SpriteHelpers.UnitRect(sprite));
this.textureId = sprite.Id;
this.color = color;
return(this);
}
// create a new polygon with a list of points (which won't change)
public Polygon(IEnumerable <Point2Dmm> pts)
{
var ptlist = new List <Point2Dmm>(pts);
PolyClose(ptlist); // make sure the polygon is closed by duplicating the first point to the end, if necessary
PtList = ptlist;
PtListOpen = new List <Point2Dmm>(PtList);
PtListOpen.RemoveAt(PtList.Count - 1); // remove the last point, which is a duplicate of the first
Area = PolyArea(PtList);
Type = PolyType(PtList, Area);
}
public SceneObjectBuilder StartSprite(float z, int textureId, Color color)
{
this.applyPolygonData();
this.currentPolygonType = PolygonType.Sprite;
this.vertexData[z] = new List <float>();
this.textureId = textureId;
this.color = color;
return(this);
}
public static void CreatePrefabs(List <BlockDataGroup> blockDataGroups, PolygonType polygonType)
{
if (blockDataGroups == null || blockDataGroups.Count == 0)
{
return;
}
Category category = blockDataGroups[0].category;
CreatePrefabsWithDataGroup(blockDataGroups, category, polygonType);
}
public static string Fbx(Category category, PolygonType pType)
{
if (category == Category.sticker)
{
return(Sticker_Fbx_Dir);
}
if (category == Category.custom)
{
return(Custom_Fbx_Dir);
}
return(GetPath(FBX_NAME, category, pType));
}
private static void ExtractInteriorPolygon(ILinearRing[] holes, PolygonType sur)
{
Collection<AbstractRingPropertyType> lin = sur.Interior as Collection<AbstractRingPropertyType>;
int i = 0;
foreach (AbstractRingPropertyType ringis in lin)
{
LinearRingType lii = ringis.Ring as LinearRingType;
foreach (DirectPositionListType rings in lii.Items)
{
List<Coordinate> lstCoor = ExtractCoordinates(rings);
holes[i]=new LinearRing(lstCoor);
i++;
}
}
}
public SweepEvent(Point p, bool isLeft, PolygonType polygonType, SweepEvent otherSweepEvent)
: this(p,isLeft,polygonType,otherSweepEvent, EdgeType.NORMAL)
{
}
public SweepEvent(Point p, bool isLeft, PolygonType polygonType)
: this(p,isLeft,polygonType,null, EdgeType.NORMAL)
{
}
// -------------------------------------------------
public RegPoly_Combi (PolygonType polytype, Point center, int rad, int apexes, double angleDegree, Color clr)
{
type = polytype;
id = Auxi_Common .UniqueID;
ptC = center;
radius = Math .Max (Math .Abs (rad), minR);
nApexes = Math .Max (Math .Abs (apexes), 3);
angle = Auxi_Convert .DegreeToRadian (Auxi_Common .LimitedDegree (angleDegree));
brush = new SolidBrush (clr);
}
void ProcessSegment(Segment segment, PolygonType polygonType)
{
if (Point.EqualsBoth(segment.start, segment.end)) return;
SweepEvent e1 = new SweepEvent(segment.start, true, polygonType);
SweepEvent e2 = new SweepEvent(segment.end, true, polygonType, e1);
e1.otherSE = e2;
if (e1.p.x < e2.p.x - Point.PRECISION ) {
e2.isLeft = false;
} else if (e1.p.x > e2.p.x + Point.PRECISION) {
e1.isLeft = false;
} else if (e1.p.y < e2.p.y - Point.PRECISION) { // the segment is vertical. The bottom endpoint is processed before the top endpoint
e2.isLeft = false;
} else {
e1.isLeft = false;
}
// Pushing it so the que is sorted from left to right, with object on the left
// having the highest priority.
eventQueue.Enqueue(e1);
eventQueue.Enqueue(e2);
}
private static int EncodeClassificationIndex(Side side1, PolygonType type1, Side side2, PolygonType type2)
{
return (((int)side1 + (int)type1) << 2) + (int)side2 + (int)type2;
}
public static PolygonType ToGmlPolygon(this Polygon polygon)
{
PolygonType gmlPolygon = new PolygonType();
if (polygon.LineStrings.Count > 0) {
gmlPolygon.exterior = new AbstractRingPropertyType();
if (!polygon.LineStrings[0].IsClosed()) {
polygon.LineStrings[0].Positions.Add(polygon.LineStrings[0].Positions[0]);
}
gmlPolygon.exterior.Item = ToGmlLinearRing(polygon.LineStrings[0]);
if (polygon.LineStrings.Count > 1) {
var interiors = new List<AbstractRingPropertyType>();
foreach (var lineString in polygon.LineStrings.Take(1)) {
var interior = new AbstractRingPropertyType();
if (!lineString.IsClosed()) {
lineString.Positions.Add(lineString.Positions[0]);
}
interior.Item = ToGmlLinearRing(lineString);
interiors.Add(interior);
}
gmlPolygon.interior = interiors.ToArray();
}
}
return gmlPolygon;
}
public static PolygonType ToGmlPolygon(this Polygon polygon)
{
PolygonType gmlPolygon = new PolygonType();
if (polygon.LineStrings.Count > 0) {
var exterior = new AbstractRingPropertyType();
gmlPolygon.Item = exterior;
gmlPolygon.ItemElementName = ItemChoiceType5.exterior;
if (!polygon.LineStrings[0].IsClosed()) {
polygon.LineStrings[0].Positions.Add(polygon.LineStrings[0].Positions[0]);
}
exterior.Item = ToGmlLinearRing(polygon.LineStrings[0]);
if (polygon.LineStrings.Count > 1) {
var interiors = new List<AbstractRingPropertyType>();
foreach (var lineString in polygon.LineStrings.Take(1)) {
var interior = new AbstractRingPropertyType();
if (!lineString.IsClosed()) {
lineString.Positions.Add(lineString.Positions[0]);
}
exterior.Item = ToGmlLinearRing(lineString);
interiors.Add(interior);
}
gmlPolygon.Items1 = interiors.ToArray();
gmlPolygon.Items1ElementName = interiors.Select<AbstractRingPropertyType, Items1ChoiceType3>(int1 => Items1ChoiceType3.interior).ToArray();
}
}
return gmlPolygon;
}
public IntersectionClassification ClassifyIntersection(Side side1, PolygonType type1, Side side2, PolygonType type2)
{
return m_classificationTable[EncodeClassificationIndex(side1, type1, side2, type2)];
}
public uint surf_index; // surface index
#endregion Fields
#region Constructors
public Polygon(PolygonType type, int flags = 0)
{
Type = type; Flags = flags;
}
private Edge PrepareActiveEdge(int boundPairIndex, ref MyPolygon.Vertex lowerVertex, ref MyPolygon.Vertex upperVertex, PolygonType polyType, Side side)
{
Edge newEdge = new Edge();
newEdge.BoundPairIndex = boundPairIndex;
newEdge.BoundPairSide = side;
newEdge.Kind = polyType;
if (polyType == PolygonType.CLIP)
{
newEdge.OutputSide = m_operation.ClipInvert ? OtherSide(side) : side;
}
else
{
newEdge.OutputSide = m_operation.SubjectInvert ? OtherSide(side) : side;
}
RecalculateActiveEdge(ref newEdge, ref lowerVertex, ref upperVertex, side);
return newEdge;
}
private int SortInMinimum(ref Edge leftEdge, ref Edge rightEdge, PolygonType type)
{
bool parity = false;
int i = 0;
while (i < m_activeEdgeList.Count)
{
var edge = m_activeEdgeList[i];
if (CompareEdges(ref leftEdge, ref edge) == -1) break;
if (edge.Kind != type)
{
parity = !parity;
}
++i;
}
bool contributing = m_operation.InitializeContributing(parity, type);
leftEdge.Contributing = contributing;
rightEdge.Contributing = contributing;
return i;
}
// ------------------------------------------------- SelectdIndexChanged_comboPolygonType
private void SelectdIndexChanged_comboPolygonType (object sender, EventArgs e)
{
if (bAfterInit)
{
polytype = (PolygonType) (sender as ComboBox) .SelectedIndex;
NewSet ();
RenewMover ();
Invalidate ();
}
}
/// <summary>
/// Find points on the left and right side.
/// </summary>
/// <param name="from">"From" polygon reference</param>
/// <param name="to">"To" polygon reference</param>
/// <param name="left">Point on the left side</param>
/// <param name="right">Point on the right side</param>
/// <param name="fromType">Polygon type of "From" polygon</param>
/// <param name="toType">Polygon type of "To" polygon</param>
/// <returns>True, if points found. False, if otherwise.</returns>
public bool GetPortalPoints(PolyId from, PolyId to, ref Vector3 left, ref Vector3 right, ref PolygonType fromType, ref PolygonType toType)
{
MeshTile fromTile;
Poly fromPoly;
if (nav.TryGetTileAndPolyByRef(from, out fromTile, out fromPoly) == false)
return false;
fromType = fromPoly.PolyType;
MeshTile toTile;
Poly toPoly;
if (nav.TryGetTileAndPolyByRef(to, out toTile, out toPoly) == false)
return false;
toType = toPoly.PolyType;
return GetPortalPoints(from, fromPoly, fromTile, to, toPoly, toTile, ref left, ref right);
}
private void ProcessOldHorizontalEdges(float bottomY, ref float endX, ref PolygonType endType, ref int from, int to)
{
float currentEnd = endX;
PolygonType currentType = endType;
endX = float.PositiveInfinity;
endType = PolygonType.SUBJECT;
for (int j = from; j < to; ++j)
{
var horizontalEdge = m_activeEdgeList[j];
Debug.Assert(horizontalEdge.TopY == bottomY && horizontalEdge.DXdy != 0.0f, "The edge was not a horizontal edge!?");
float edgeEndX = horizontalEdge.BottomX + horizontalEdge.DXdy;
if (edgeEndX == currentEnd && horizontalEdge.Kind == currentType)
{
BoundPair pair = m_usedBoundPairs[horizontalEdge.BoundPairIndex];
MyPolygon.Vertex endVertex, newTopVertex;
pair.Parent.GetVertex(horizontalEdge.TopVertexIndex, out endVertex);
Vector3 newPosition = endVertex.Coord;
if (horizontalEdge.Contributing)
{
if (horizontalEdge.OutputSide == Side.LEFT)
{
horizontalEdge.AssociatedPolygon.Append(newPosition);
}
else
{
horizontalEdge.AssociatedPolygon.Prepend(newPosition);
}
}
if (horizontalEdge.BoundPairSide == Side.LEFT)
{
pair.Parent.GetVertex(endVertex.Next, out newTopVertex);
}
else
{
pair.Parent.GetVertex(endVertex.Prev, out newTopVertex);
}
RecalculateActiveEdge(ref horizontalEdge, ref endVertex, ref newTopVertex, horizontalEdge.BoundPairSide);
m_activeEdgeList[j] = horizontalEdge;
if (horizontalEdge.TopY == bottomY && horizontalEdge.DXdy != 0.0f)
{
float newEndX = horizontalEdge.BottomX + horizontalEdge.DXdy;
if (newEndX < endX || (newEndX == endX && horizontalEdge.Kind == PolygonType.CLIP && endType == PolygonType.SUBJECT))
{
endX = newEndX;
endType = horizontalEdge.Kind;
}
}
else
{
// The "horizontalEdge" is no longer horizontal :-) We intersect it with horizontal edges above
int risingEdge = j;
for (int k = j - 1; k >= from; --k)
{
var horizontalEdge2 = m_activeEdgeList[k];
Vector3 intersection = new Vector3(horizontalEdge.BottomX, bottomY, 0.0f);
var intersectionClassification = m_operation.ClassifyIntersection(horizontalEdge2.OutputSide, horizontalEdge2.Kind, horizontalEdge.OutputSide, horizontalEdge.Kind);
PerformIntersection(k, risingEdge, ref horizontalEdge2, ref horizontalEdge, ref intersection, intersectionClassification);
risingEdge = k;
}
++from;
}
}
else
{
float newEndX = horizontalEdge.BottomX + horizontalEdge.DXdy;
if (newEndX < endX || (newEndX == endX && horizontalEdge.Kind == PolygonType.CLIP && endType == PolygonType.SUBJECT))
{
endX = newEndX;
endType = horizontalEdge.Kind;
}
}
}
}
/**
* \brief Draws planes around the edges of a mesh.
* @param _points The points to use as a guide.
* @param _modifier Multiply plane X and Y dimensions component wise.
*/
public void DrawEdgePlanes(List<Vector2> _points, PolygonType convexity, Vector2 _modifier, float area)
{
Vector2[] points = _points.ToArray();
if(convexity == PolygonType.ConcaveClockwise || convexity == PolygonType.ConvexClockwise)
Array.Reverse(points);
for(int i = 0; i < points.Length; i++)
{
float x1, x2, y1, y2;
x1 = points[i].x;
y1 = points[i].y;
if(i > points.Length-2) {
x2 = points[0].x;
y2 = points[0].y;
}
else {
x2 = points[i+1].x;
y2 = points[i+1].y;
}
float length = Vector2.Distance(new Vector2(x1, y1), new Vector2(x2, y2));
length *= drawSettings.edgeLengthModifier;
if(length < drawSettings.minLengthToDraw)
continue;
float angle = Mathf.Atan2(y2 - y1, x2 - x1) * Mathf.Rad2Deg;
if( Mathf.Abs(angle) > 180-drawSettings.maxAngle && Mathf.Abs(angle) < 180+drawSettings.maxAngle)
;
else
continue;
GameObject boxColliderObj = new GameObject();
boxColliderObj.AddComponent<MeshFilter>().sharedMesh = MeshPlane();
boxColliderObj.AddComponent<MeshRenderer>();
boxColliderObj.name = "EdgePlane " + angle;
boxColliderObj.transform.position = new Vector3( ((x1 + x2)/2f), ((y1+y2)/2f), drawSettings.zPosition + drawSettings.edgeOffset);
boxColliderObj.GetComponent<MeshRenderer>().sharedMaterial = drawSettings.edgeMaterial;
Vector2[] uvs = boxColliderObj.GetComponent<MeshFilter>().sharedMesh.uv;
float imgScale = 1f;
if(drawSettings.edgeMaterial != null)
imgScale = ((float)drawSettings.edgeMaterial.mainTexture.width / drawSettings.edgeMaterial.mainTexture.height);
boxColliderObj.GetComponent<MeshFilter>().sharedMesh.uv = DrawUtility.ArrayMultiply(uvs, new Vector2( length / imgScale, 1f)).ToArray();
if(drawSettings.areaRelativeHeight)
boxColliderObj.transform.localScale = new Vector3(
length,
Mathf.Clamp(Mathf.Abs(area) * drawSettings.edgeHeight,
drawSettings.minEdgeHeight,
drawSettings.maxEdgeHeight),
2f);
else
boxColliderObj.transform.localScale = new Vector3(length, drawSettings.edgeHeight, 2f);
boxColliderObj.transform.rotation = Quaternion.Euler( new Vector3(0f, 0f, angle) );
boxColliderObj.transform.parent = LastDrawnObject.transform;
}
}
