public CPolygon GetDataAddressW() { global::System.IntPtr cPtr = C4dApiPINVOKE.PolygonTag_GetDataAddressW(swigCPtr); CPolygon ret = (cPtr == global::System.IntPtr.Zero) ? null : new CPolygon(cPtr, false); return(ret); }
protected override AbstractShape createShapes(string code) { AbstractShape shape = null; switch (code) { case "Circle": shape = new CCircle(); break; case "Rectangle": shape = new CRectangle(); break; case "Polygon": shape = new CPolygon(); break; case "Star": shape = new CStar(); break; case "Group": shape = new CGroup(); break; } return(shape); }
private static List <CPoint> SimplifyAccordExistEdges(CPolygon EnlargedCpg, List <CEdge> OriginalCEdgeLt, string strSimplification, double dblThreshold) { //EnlargedCpg.SetGeometricProperties(); EnlargedCpg.FormCEdgeLt(); //EnlargedCpg.SetCEdgeLtLength(); EnlargedCpg.SetCEdgeToCpts(); //EnlargedCpg.SetCEdgeLtAxisAngle(); //EnlargedCpg.SetAngleDiffLt(); //CSaveFeature.SaveCpgEb(clipperMethods.ScaleCpgEb(CHelpFunc.MakeLt(EnlargedCpg), 1 / CConstants.dblFclipper), //"EnlargedCpg", pesriSimpleFillStyle: esriSimpleFillStyle.esriSFSHollow, blnVisible: false); var EnlargedCEdgeHS = new HashSet <CEdge>(EnlargedCpg.CEdgeLt); //CSaveFeature.SaveCEdgeEb(clipperMethods.ScaleCEdgeEb( EnlargedCEdgeHS, 1 / CConstants.dblFclipper), "EnlargedCEdgeHS", // blnVisible: false); _intEdgeCountBefore += EnlargedCpg.CptLt.Count - 1; var simplifiedcptlt = SimplifyAccordExistEdges(EnlargedCpg.CptLt, OriginalCEdgeLt, EnlargedCEdgeHS, strSimplification, dblThreshold).ToList(); _intEdgeCountAfter += simplifiedcptlt.Count - 1; //CPolygon simplifiedcpg = new CPolygon(EnlargedCpg.ID, // clipperMethods.ScaleCptEb(simplifiedcptlt, 1 / CConstants.dblFclipper).ToList()); //CSaveFeature.SaveCpg(simplifiedcpg, "simplifiedcpg", // pesriSimpleFillStyle: esriSimpleFillStyle.esriSFSHollow, blnVisible: false); return(simplifiedcptlt); }
public static IEnumerable <CPolygon> ScaleCpgEb(IEnumerable <CPolygon> cpgeb, double dblFactor) { foreach (var cpg in cpgeb) { var scaledcpg = new CPolygon(cpg.ID, ScaleCptEb(cpg.CptLt, dblFactor).ToList()); //scale the holes of cpg var cpgPairSK = new Stack <CValPair <CPolygon, CPolygon> >(); cpgPairSK.Push(new CValPair <CPolygon, CPolygon>(cpg, scaledcpg)); do { var cpggroup = cpgPairSK.Pop(); var recursivecpg = cpggroup.val1; var scaledrecursivecpg = cpggroup.val2; if (recursivecpg.HoleCpgLt != null && recursivecpg.HoleCpgLt.Count > 0) { scaledrecursivecpg.HoleCpgLt = new List <CPolygon>(recursivecpg.HoleCpgLt.Count); foreach (var holecpg in recursivecpg.HoleCpgLt) { var scaledholecpg = new CPolygon(holecpg.ID, ScaleCptEb(holecpg.CptLt, dblFactor).ToList()); scaledholecpg.IsHole = true; scaledrecursivecpg.HoleCpgLt.Add(scaledholecpg); //scaledholecpg.ParentCpg = scaledrecursivecpg; cpgPairSK.Push(new CValPair <CPolygon, CPolygon>(holecpg, scaledholecpg)); } } } while (cpgPairSK.Count > 0); yield return(scaledcpg); } }
/// <summary> /// Save a feature layer of IPolygon to Ipe /// </summary> public static string TranCpgToIpe(CPolygon cpg, IFillSymbol pFillSymbol, IEnvelope pFLayerEnv, CEnvelope pIpeEnv, string strBoundWidth = "normal") { //get the color of the filled part //we are not allowed to directly use "var pFillRgbColor = pFillSymbol.Color as IRgbColor;" //Nor can we use "var pFillRgbColor = pFillSymbol.Color.RGB as IRgbColor;" //pFillSymbol.Color.RGB has type 'int' IColor pFillSymbolColor = new RgbColorClass(); pFillSymbolColor.RGB = pFillSymbol.Color.RGB; CColor cColor = new CUtility.CColor(pFillSymbolColor as IRgbColor); var pSimpleFillSymbol = pFillSymbol as ISimpleFillSymbol; if (pSimpleFillSymbol != null) { if (pSimpleFillSymbol.Style == esriSimpleFillStyle.esriSFSHollow || pSimpleFillSymbol.Style == esriSimpleFillStyle.esriSFSNull) { cColor = null; } } //get the color of the out line var pOutlineRgbColor = pFillSymbol.Outline.Color as IRgbColor; if (strBoundWidth == "") { strBoundWidth = pFillSymbol.Outline.Width.ToString(); } //append the string return(CIpeDraw.DrawCpg(cpg, pFLayerEnv, pIpeEnv, new CColor(pOutlineRgbColor), cColor, strBoundWidth)); }
//public static CPolygon SimplifyCpgFreeEdges(CPolygon EnlargedCpg, List<CEdge> OriginalCEdgeLt, double dblDepsilon) //{ // //var ConflictCEdgeLt = new List<CEdge>(OriginalCEdgeLt); // EnlargedCpg.SetGeometricProperties(); // //ConflictCEdgeLt.AddRange(EnlargedCpg.CEdgeLt); // ////***********why do we consider holes? // //if (EnlargedCpg.HoleCpgLt != null) // //{ // // EnlargedCpg.HoleCpgLt.ForEach(holecpg => ConflictCEdgeLt.AddRange(holecpg.CEdgeLt)); // //} // return SimplifyAccordRightAnglesAndExistEdges(EnlargedCpg, ConflictCEdgeLt, dblDepsilon); //} /// <summary> /// the angle from the baseline to the firstedge should smaller than PI /// </summary> /// <param name="cpg"></param> /// <param name="ocpg"></param> /// <param name="dblThreshold"></param> /// <returns>the first vertex and the last vertex are identical</returns> public static CPolygon SimplifyCpgAccordExistEdges(CPolygon EnlargedCpg, List <CEdge> OriginalCEdgeLt, string strSimplification, double dblThreshold) { //generate new polygon var newcptlt = SimplifyAccordExistEdges(EnlargedCpg, OriginalCEdgeLt, strSimplification, dblThreshold); if (EnlargedCpg.HoleCpgLt != null) { List <List <CPoint> > newholecptltlt; newholecptltlt = new List <List <CPoint> >(EnlargedCpg.HoleCpgLt.Count); foreach (var holeEnlargedCpg in EnlargedCpg.HoleCpgLt) { var newholecptlt = SimplifyAccordExistEdges(holeEnlargedCpg, OriginalCEdgeLt, strSimplification, dblThreshold); newholecptltlt.Add(newholecptlt); } var simplifiedCpg = new CPolygon(EnlargedCpg.ID, newcptlt, newholecptltlt); //simplifiedCpg.HoleCpgLt.ForEach(holecpg => holecpg.IsOriginal = false); //these holes are return(simplifiedCpg); } else { return(new CPolygon(EnlargedCpg.ID, newcptlt)); } }
/// <summary> /// Save a feature layer of IPolygon to Ipe /// </summary> public static string TranIpgBoundToIpe(IPolygon ipg, IEnvelope pFLayerEnv, CEnvelope pIpeEnv, CColor StrokeColor, string strBoundWidth = "normal", string strDash = "normal") { ////get the color of the filled part ////we are not allowed to directly use "var pFillRgbColor = pFillSymbol.Color as IRgbColor;" ////Nor can we use "var pFillRgbColor = pFillSymbol.Color.RGB as IRgbColor;" ////pFillSymbol.Color.RGB has type 'int' //IColor pFillSymbolColor = new RgbColorClass(); //pFillSymbolColor.RGB = pFillSymbol.Color.RGB; //var pFillSymbolRgbColor = pFillSymbolColor as IRgbColor; ////get the color of the out line //var pOutlineRgbColor = pFillSymbol.Outline.Color as IRgbColor; //if (strBoundWidth == "") //{ // strBoundWidth = pFillSymbol.Outline.Width.ToString(); //} //get the feature CPolygon cpg = new CPolygon(0, ipg as IPolygon4); //append the string return(CIpeDraw.DrawCpgBound(cpg, pFLayerEnv, pIpeEnv, StrokeColor, strBoundWidth, strDash)); }
public CPolygon GetPolygonR() { global::System.IntPtr cPtr = C4dApiPINVOKE.PolygonObject_GetPolygonR(swigCPtr); CPolygon ret = (cPtr == global::System.IntPtr.Zero) ? null : new CPolygon(cPtr, false); return(ret); }
public override bool UnPack(BinaryReader reader) { LeafIndex = reader.ReadInt32(); if (PackTreeType != BspTreeType.Physics) { return(true); } Solid = reader.ReadUInt32(); Sphere.UnPack(reader); uint numPolys = reader.ReadUInt32(); if (numPolys > 0u) { InPolys = new CPolygon[numPolys]; for (uint i = 0u; i < numPolys; i++) { InPolys[i] = PackPolys[reader.ReadUInt16()]; } } return(true); }
public void SetPolygonAt(int inx, CPolygon v) { C4dApiPINVOKE.PolygonObject_SetPolygonAt(swigCPtr, inx, CPolygon.getCPtr(v)); if (C4dApiPINVOKE.SWIGPendingException.Pending) { throw C4dApiPINVOKE.SWIGPendingException.Retrieve(); } }
private static HashSet <CptEdgeDis> GroupCpgsAndBridgesForEachCluster_Prim(IEnumerable <CptEdgeDis> CptEdgeDisEb) { foreach (var cptEdgeDis in CptEdgeDisEb) { cptEdgeDis.CpgPairIncr.val1.isTraversed = false; cptEdgeDis.CpgPairIncr.val2.isTraversed = false; } var CpgCptEdgeDisLtDt = AttachCptEdgeDisLtToCpg(CptEdgeDisEb); var mincptEdgeDis = CptEdgeDisEb.GetMin(cptEdgeDis => cptEdgeDis.dblDis).Item1; var intCpgCount = CpgCptEdgeDisLtDt.Count; var FirstCpg = mincptEdgeDis.CpgPairIncr.val1; FirstCpg.isTraversed = true; var groupcpglt = new List <CPolygon>(intCpgCount); groupcpglt.Add(FirstCpg); var BridgeCptEdgeDisSS = new HashSet <CptEdgeDis>(); var QueueSS = new SortedSet <CptEdgeDis>(CCmpCptEdgeDis_Dis.sComparer); FindandAddBridgeCptEdgeDisIntoQueue(QueueSS, FirstCpg, CpgCptEdgeDisLtDt); do { //brige polygons by shortest connections, to avoid crossed bridges var minCptEdgeDis = QueueSS.Min; QueueSS.Remove(minCptEdgeDis); var cpg1 = minCptEdgeDis.CpgPairIncr.val1; var cpg2 = minCptEdgeDis.CpgPairIncr.val2; CPolygon BridgedCpg = null; if (cpg1.isTraversed == true && cpg2.isTraversed == true) { continue; } else if (cpg1.isTraversed == false && cpg2.isTraversed == true) { BridgedCpg = cpg1; } else if (cpg1.isTraversed == true && cpg2.isTraversed == false) { BridgedCpg = cpg2; } else { throw new ArgumentException("impossible!"); } BridgedCpg.isTraversed = true; groupcpglt.Add(BridgedCpg); BridgeCptEdgeDisSS.Add(minCptEdgeDis); FindandAddBridgeCptEdgeDisIntoQueue(QueueSS, BridgedCpg, CpgCptEdgeDisLtDt); } while (QueueSS.Count > 0 && groupcpglt.Count < intCpgCount); return(BridgeCptEdgeDisSS); }
private IEnumerable <CPolygon> GrowAndClipMergedCpg_Overlap(CPolygon mergedcpg, double dblProp, string strSimplification, string strBufferStyle, double dblMiterLimit) { //dblProp = 0.2; //dblProp = 1; double dblCurrentScale = _dblStartScale + dblProp * (_dblTargetScale - _dblStartScale); double dblCurrentGrow = dblProp * _dblTotalGrow * CConstants.dblFclipper; double dblCurrentEpsilon = Math.Min(dblCurrentGrow / dblMiterLimit, _dblEpsilon * dblCurrentScale * CConstants.dblFclipper); double dblCurrentErosion = _dblErosion * dblCurrentScale * CConstants.dblFclipper; //double dblCurrentDilation = Math.Max(dblCurrentEpsilon / 2, dblProp * _dblDilation * dblCurrentScale * CConstants.dblFclipper); double dblCurrentDilation = (dblCurrentGrow - dblMiterLimit * dblCurrentErosion) / (dblMiterLimit - 1); //dblCurrentErosion = 0; //dblCurrentDilation = 0; var clipPathsFirstLevel = clipperMethods.GenerateClipPathsByCpgEb(mergedcpg.ClipCpgLt); var LastAndClippedPath = new Paths(); if (mergedcpg.SubCpgLt == null || mergedcpg.SubCpgLt.Count < 2) { LastAndClippedPath.AddRange(DilateErodeOffsetSimplifyCpg(mergedcpg, dblCurrentGrow, dblCurrentDilation, dblCurrentErosion, dblCurrentEpsilon, strSimplification, strBufferStyle, dblMiterLimit)); } else { //var SubCpgLt = mergedcpg.SubCpgLt; var submergedcpglt = MergeCloseCpgsAndAddBridges(mergedcpg.SubCpgLt, false, //---Merge---// dblCurrentGrow, dblCurrentDilation, dblCurrentEpsilon); //var BridgeCpipeDt = mergedcpg.BridgeCpipeDt; foreach (var submergedcpg in submergedcpglt) { LastAndClippedPath.AddRange(DilateErodeOffsetSimplifyCpg(submergedcpg, dblCurrentGrow, dblCurrentDilation, dblCurrentErosion, dblCurrentEpsilon, strSimplification, strBufferStyle, dblMiterLimit)); } } //CSaveFeature.SaveCEdgeEb(clipperMethods.ScaleCEdgeEb( // clipperMethods.ConvertPathsToCEdgeEb(LastAndClippedPath, true), 1 / CConstants.dblFclipper), // "GrownPathsWithoutMergeOrClip", blnVisible: false); LastAndClippedPath.AddRange(mergedcpg.LastTimePaths); var unitedPaths = clipperMethods.Clip_Paths(LastAndClippedPath, true, mergedcpg.LastTimePaths, true, ClipType.ctUnion); //var unitedPaths = LastAndClippedPath; var clippedPolyTree = clipperMethods.Clip_PolyTree(unitedPaths, true, clipPathsFirstLevel, true, ClipType.ctIntersection); mergedcpg.LastTimePaths = Clipper.PolyTreeToPaths(clippedPolyTree); var GrownAndClippedCpg = clipperMethods.GenerateCpgEbByPolyTree(clippedPolyTree, mergedcpg.ID, true); //CSaveFeature.SavePolyTreeAsCpgEb(clippedPolyTree, "GrownMergeClipPolyTree", // pesriSimpleFillStyle: esriSimpleFillStyle.esriSFSNull, blnVisible: false); return(GrownAndClippedCpg); }
private static void UpdateCpgCptEdgeDisLtDt( ref Dictionary <CPolygon, List <CptEdgeDis> > CpgCptEdgeDisLtDt, CPolygon cpg, CptEdgeDis cptEdgeDis) { if (CpgCptEdgeDisLtDt.ContainsKey(cpg) == false) { CpgCptEdgeDisLtDt[cpg] = new List <CptEdgeDis>(); } CpgCptEdgeDisLtDt[cpg].Add(cptEdgeDis); }
public static IFeatureLayer SaveCpg(CPolygon Cpg, string strFileName, List <string> pstrFieldNameLt = null, List <esriFieldType> pesriFieldTypeLt = null, List <List <object> > pobjectValueLtLt = null, int intRed = _intColor, int intGreen = _intColor, int intBlue = _intColor, double dblWidth = 1, int intOutlineRed = _intColor, int intOutlineGreen = _intColor, int intOutlineBlue = _intColor, esriSimpleFillStyle pesriSimpleFillStyle = esriSimpleFillStyle.esriSFSSolid, string strSymbolLayerPath = null, bool blnVisible = true) { return(SaveCGeoEb(CHelpFunc.MakeLt(Cpg), esriGeometryType.esriGeometryPolygon, strFileName, pstrFieldNameLt, pesriFieldTypeLt, pobjectValueLtLt, intRed, intGreen, intBlue, dblWidth, intOutlineRed, intOutlineGreen, intOutlineBlue, pesriSimpleFillStyle, strSymbolLayerPath, blnVisible)); }
private void btnArea_Click(object sender, EventArgs e) { string strType = ""; var cptlt = GetCptLt(rtbInput.Text, out strType); cptlt.Add(cptlt[0]); CPolygon cpg = new CPolygon(0, cptlt); cpg.SetAreaSimple(); txtArea.Text = cpg.dblAreaSimple.ToString(); }
public void AddWeightData(SceneNodeContainer snc, PolygonObject polyOb, CAWeightTag weightTag, IEnumerable <int> range) { if (weightTag == null || polyOb == null) { return; } List <VertexWeightList> weightMap = new List <VertexWeightList>(); List <float4x4> bindingMatrices = new List <float4x4>(); foreach (int j in range) { using (CPolygon poly = polyOb.GetPolygonAt(j)) { foreach (int iVert in GetPolyPointIndices(poly, polyOb)) { var vertexWeights = new List <VertexWeight>(); for (int iJoint = 0; iJoint < weightTag.GetJointCount(); iJoint++) { double weight = weightTag.GetWeight(iJoint, iVert); // Leave out zero weights. This will save space for the sparse weight table. if (Math.Abs(weight) > double.Epsilon) { vertexWeights.Add(new VertexWeight { JointIndex = iJoint, Weight = (float)weight }); } } vertexWeights.Sort((vw1, vw2) => ((int)(vw1.Weight - vw2.Weight))); weightMap.Add(new VertexWeightList { VertexWeights = vertexWeights }); } } } for (int iJoint = 0; iJoint < weightTag.GetJointCount(); iJoint++) { // Add Binding Matrix JointRestState jointRestState = weightTag.GetJointRestState(iJoint); float4x4 mat = (float4x4)(jointRestState.m_oMi * weightTag.GetGeomMg()); bindingMatrices.Add(mat); } _weightObjects.Add(new WeightObject() { SceneNodeContainer = snc, WeightTag = weightTag, WeightMap = weightMap, BindingMatrices = bindingMatrices }); }
//private static CPolygon GenerateCpgEbByPolyNode(PolyNode cpgnode, int intID, bool blnReverse = false) //{ // var cptlt = ContourToCptEb(cpgnode.Contour, blnReverse).ToList(); // var holecptlt = GetOLHCptLtEb(cpgnode, blnReverse).ToLtLt(); // return new CPolygon(intID, cptlt, holecptlt); //} //public static IEnumerable<CPolygon> GenerateOLHCpgEbByPolyTree(PolyTree pPolyTree, int intID, bool blnReverse = false) //{ // foreach (var polyNode in pPolyTree.Childs) // { // yield return GenerateOLHCpgEbByPolyNode(polyNode, intID, blnReverse); // } //} private static CPolygon GenerateOLHCpgEbByPolyNode(PolyNode cpgnode, int intID, bool blnReverse = false) { //tiny edges cause problems for our Imai-Iri algorithm var cptlt = CGeoFunc.RemoveClosePointsForCptEb(ConvertPathToCptEb(cpgnode.Contour, blnReverse)).ToList(); var holecptlt = GetOLHCptLtEb(cpgnode, blnReverse).ToLtLt(); var cpg = new CPolygon(intID, cptlt, holecptlt); //CSaveFeature.SaveCpgEb(clipperMethods.ScaleCpgEb(CHelpFunc.MakeLt(cpg), 1 / CConstants.dblFclipper), "Cpg"); return(cpg); }
/********************************************************** * To check the Pt is in the Triangle or not. * If the Pt is in the line or is a vertex, then return true. * If the Pt is out of the Triangle, then return false. * * This method is used for triangle only. ***********************************************************/ private bool TriangleContainsPoint(CPoint2D[] trianglePts, CPoint2D pt) { if (trianglePts.Length != 3) { return(false); } for (int i = trianglePts.GetLowerBound(0); i < trianglePts.GetUpperBound(0); i++) { if (pt.EqualsPoint(trianglePts[i])) { return(true); } } bool bIn = false; CLineSegment line0 = new CLineSegment(trianglePts[0], trianglePts[1]); CLineSegment line1 = new CLineSegment(trianglePts[1], trianglePts[2]); CLineSegment line2 = new CLineSegment(trianglePts[2], trianglePts[0]); if (pt.InLine(line0) || pt.InLine(line1) || pt.InLine(line2)) { bIn = true; } else //point is not in the lines { double dblArea0 = CPolygon.PolygonArea(new CPoint2D[] { trianglePts[0], trianglePts[1], pt }); double dblArea1 = CPolygon.PolygonArea(new CPoint2D[] { trianglePts[1], trianglePts[2], pt }); double dblArea2 = CPolygon.PolygonArea(new CPoint2D[] { trianglePts[2], trianglePts[0], pt }); if (dblArea0 > 0) { if ((dblArea1 > 0) && (dblArea2 > 0)) { bIn = true; } } else if (dblArea0 < 0) { if ((dblArea1 < 0) && (dblArea2 < 0)) { bIn = true; } } } return(bIn); }
private static IEnumerable <Path> GeneratePathEbByCpg(CPolygon cpg) { yield return(GeneratePathByCptEb(cpg.CptLt, true)); if (cpg.HoleCpgLt != null) { foreach (var holecpg in cpg.HoleCpgLt) { yield return(GeneratePathByCptEb(cpg.CptLt, true)); } } }
public static CPolygon ConvertToClipper(Polygon2d poly, double nIntScale) { int N = poly.VertexCount; CPolygon clipper_poly = new CPolygon(N); for (int i = 0; i < N; ++i) { Vector2d v = poly[i]; clipper_poly.Add(new IntPoint(nIntScale * v.x, nIntScale * v.y)); } return(clipper_poly); }
public static IEnumerable <int> GetPolyPointIndices(CPolygon polygon, PolygonObject polyOb) { yield return(polygon.a); yield return(polygon.b); yield return(polygon.c); if (!IsTri(polygon, polyOb)) { yield return(polygon.d); } }
public static Paths DilateErodeOffsetCpgExterior_Paths(CPolygon Cpg, double dblGrow, double dblDilation, double dblErosion, string strBufferStyle, double dblMiterLimit) { double dblHoleIndicator = 1; if (Cpg.IsHole == true) { dblHoleIndicator = -1; } if (Cpg.ExteriorPath == null) { Cpg.SetExteriorPath(); } var overdilationPaths = Offset_Paths(CHelpFunc.MakeLt(Cpg.ExteriorPath), dblHoleIndicator * (dblGrow + dblDilation), strBufferStyle, dblMiterLimit); var erosionpaths = Offset_Paths(overdilationPaths, dblHoleIndicator * (-dblDilation - dblErosion), strBufferStyle, dblMiterLimit); //var ExteriorPath = GeneratePathByCpgExterior(Cpg); //var growndilationPaths = Offset_Paths(CHelpFunc.MakeLt(ExteriorPath), // dblHoleIndicator * (dblGrow ), strBufferStyle, dblMiterLimit); //var overdilationPaths = Offset_Paths(growndilationPaths, // dblHoleIndicator * (dblDilation), strBufferStyle, dblMiterLimit); //var backPaths = Offset_Paths(overdilationPaths, // dblHoleIndicator * (-dblDilation), strBufferStyle, dblMiterLimit); //var erosionpaths = Offset_Paths(backPaths, // dblHoleIndicator * (- dblErosion), strBufferStyle, dblMiterLimit); //CSaveFeature.SaveCpgEb(clipperMethods.ScaleCpgLt(CHelpFunc.MakeLt(Cpg), 1 / CConstants.dblFclipper), // "Cpg"); //// CSaveFeature.SaveCEdgeEb(clipperMethods.ScaleCEdgeEb(clipperMethods.ConvertPathsToCEdgeLt( ////growndilationPaths, true), 1 / CConstants.dblFclipper), "growndilationPaths", CConstants.ParameterInitialize); //CSaveFeature.SaveCEdgeEb(clipperMethods.ScaleCEdgeEb(clipperMethods.ConvertPathsToCEdgeLt(overdilationPaths, true), // 1 / CConstants.dblFclipper), "overdilationPaths"); //// CSaveFeature.SaveCEdgeEb(clipperMethods.ScaleCEdgeEb(clipperMethods.ConvertPathsToCEdgeLt( ////backPaths, true), 1 / CConstants.dblFclipper), "backPaths", CConstants.ParameterInitialize); //CSaveFeature.SaveCEdgeEb(clipperMethods.ScaleCEdgeEb(clipperMethods.ConvertPathsToCEdgeLt(erosionpaths, true), // 1 / CConstants.dblFclipper), "erosionpaths"); return(Offset_Paths(erosionpaths, dblHoleIndicator * dblErosion, strBufferStyle, dblMiterLimit)); }
private void btnCentroid_Click(object sender, EventArgs e) { string strType = ""; var cptlt = GetCptLt(rtbInput.Text, out strType); cptlt.Add(cptlt[0]); CPolygon cpg = new CPolygon(0, cptlt); var ccpt = cpg.SetCentroidCptSimple(); txtCentroidX.Text = ccpt.X.ToString(); txtCentroidY.Text = ccpt.Y.ToString(); txtCentroidXY.Text = txtCentroidX.Text + " " + txtCentroidY.Text; }
public static Polygon2d ConvertFromClipper(CPolygon clipper_poly, double nIntScale) { double scale = 1.0 / (double)nIntScale; int N = clipper_poly.Count; Polygon2d poly = new Polygon2d(); for (int i = 0; i < N; ++i) { IntPoint p = clipper_poly[i]; Vector2d v = new Vector2d((double)p.X * scale, (double)p.Y * scale); poly.AppendVertex(v); } return(poly); }
/******************************************************* * To cut an ear from polygon to make ears and an updated polygon: *******************************************************/ public void CutEar() { CPolygon polygon = new CPolygon(m_aUpdatedPolygonVertices); bool bFinish = false; //if (polygon.GetPolygonType()==PolygonType.Convex) //don't have to cut ear // bFinish=true; if (m_aUpdatedPolygonVertices.Length == 3) //triangle, don't have to cut ear { bFinish = true; } CPoint2D pt = new CPoint2D(); while (bFinish == false) //UpdatedPolygon { int i = 0; bool bNotFound = true; while (bNotFound && (i < m_aUpdatedPolygonVertices.Length)) //loop till find an ear { pt = m_aUpdatedPolygonVertices[i]; if (IsEarOfUpdatedPolygon(pt)) { bNotFound = false; //got one, pt is an ear } else { i++; } } //bNotFount //An ear found:} if (pt != null) { UpdatePolygonVertices(pt); } polygon = new CPolygon(m_aUpdatedPolygonVertices); //if ((polygon.GetPolygonType()==PolygonType.Convex) // && (m_aUpdatedPolygonVertices.Length==3)) if (m_aUpdatedPolygonVertices.Length == 3) { bFinish = true; } } //bFinish=false SetPolygons(); }
private void btnLength_Click(object sender, EventArgs e) { string strType = ""; var cptlt = GetCptLt(rtbInput.Text, out strType); if (strType == "Polyline") { CPolyline cpl = new CPolyline(0, cptlt); txtLength.Text = cpl.SetLengthSimple().ToString(); } else { cptlt.Add(cptlt[0]); CPolygon cpg = new CPolygon(0, cptlt); txtLength.Text = cpg.SetLengthSimple().ToString(); } }
private Paths DilateErodeOffsetSimplifyCpg(CPolygon cpg, double dblGrow, double dblDilation, double dblErosion, double dblEpsilon, string strSimplification, string strBufferStyle, double dblMiterLimit) { var rawPaths = new Paths(); var rawCpgEb = clipperMethods.DilateErodeOffsetSimplifyOneComponent(cpg, dblGrow, dblDilation, dblErosion, dblEpsilon, strSimplification, true, strBufferStyle, dblMiterLimit); //CSaveFeature.SaveCpgEb(rawCpgEb, "rawCpgEb" + CHelpFunc.GetTimeStampWithPrefix()); foreach (var rawCpg in rawCpgEb) { rawCpg.SetExteriorPath(); rawPaths.AddRange(rawCpg.GetAllPaths()); } if (cpg.HoleCpgLt != null && cpg.HoleCpgLt.Count > 0) { foreach (var holecpg in cpg.HoleCpgLt) { if (holecpg.ClipCpgLt == null || holecpg.ClipCpgLt.Count == 0) { continue; } var rawholePaths = new Paths(); var rawholeCpgEb = clipperMethods.DilateErodeOffsetSimplifyOneComponent(holecpg, dblGrow, dblDilation, dblErosion, dblEpsilon, strSimplification, true, strBufferStyle, dblMiterLimit); foreach (var rawholeCpg in rawholeCpgEb) { rawholeCpg.SetExteriorPath(); rawholePaths.AddRange(rawholeCpg.GetAllPaths()); } var clipPaths = clipperMethods.GenerateClipPathsByCpgEb(holecpg.ClipCpgLt); var clippedPaths = clipperMethods.Clip_Paths(rawholePaths, true, clipPaths, true, ClipType.ctIntersection); rawPaths.AddRange(clippedPaths); } } return(rawPaths); }
public void UnPack(BinaryReader reader) { CellStructId = reader.ReadUInt32(); Polygons = new CPolygon[reader.ReadUInt32()]; PhysicsPolygons = new CPolygon[reader.ReadUInt32()]; Portals = new CPolygon[reader.ReadUInt32()]; VertexArray.UnPack(reader); for (int i = 0; i < Polygons.Length; i++) { Polygons[i] = new CPolygon(); Polygons[i].UnPack(reader); } for (int i = 0; i < Portals.Length; i++) { Portals[i] = Polygons[reader.ReadUInt16()]; } reader.Align(); BspNode.PackPolys = Polygons; BspNode.PackTreeType = BspTreeType.Cell; CellBsp.UnPack(reader); for (int i = 0; i < PhysicsPolygons.Length; i++) { PhysicsPolygons[i] = new CPolygon(); PhysicsPolygons[i].UnPack(reader); } BspNode.PackPolys = PhysicsPolygons; BspNode.PackTreeType = BspTreeType.Physics; PhysicsBsp.UnPack(reader); if (reader.ReadUInt32() != 0u) { BspNode.PackPolys = Polygons; BspNode.PackTreeType = BspTreeType.Drawing; DrawingBsp.UnPack(reader); } reader.Align(); }
/**************************************************** * To fill m_aUpdatedPolygonVertices array with input array. * * m_aUpdatedPolygonVertices is a working array that will * be updated when an ear is cut till m_aUpdatedPolygonVertices * makes triangle (a convex polygon). ******************************************************/ private void SetUpdatedPolygonVertices() { int nVertices = m_aInputVertices.Length; m_aUpdatedPolygonVertices = new CPoint2D[nVertices]; for (int i = 0; i < nVertices; i++) { m_aUpdatedPolygonVertices[i] = m_aInputVertices[i]; } //m_aUpdatedPolygonVertices should be in count clock wise if (CPolygon.PointsDirection(m_aUpdatedPolygonVertices) == PolygonDirection.Clockwise) { CPolygon.ReversePointsDirection(m_aUpdatedPolygonVertices); } }
private double ComputeCpgAreaAndRemoveSmallHoles(CPolygon cpg, double dblHoleAreaLimit) { cpg.SetAreaSimple(); if (cpg.HoleCpgLt != null) { var holecpglt = new List <CPolygon>(cpg.HoleCpgLt.Count); foreach (var holecpg in cpg.HoleCpgLt) { if (holecpg.dblAreaSimple >= dblHoleAreaLimit) { holecpglt.Add(holecpg); } } cpg.HoleCpgLt = holecpglt; } return(cpg.dblAreaSimple); }