public static void RefreshSheets() { List <ADMSheet> list = new List <ADMSheet>(); foreach (MiniMapControler.IconInfo info in MapUIContainer.Instance.MinimapUI.GetBaseIconInfos()) { BasePoint basePoint = info.Point.GetComponent <BasePoint>(); Map.Instance.GetBasePointOpenState(basePoint.ID, out bool flag); if (!flag) { continue; } list.Add(new ADMSheet(info.Name.Translate(), () => Warp(basePoint.WarpPoint))); } foreach (KeyValuePair <int, AgentActor> pair in Map.Instance.AgentTable) { AgentActor agent = pair.Value; list.Add(new ADMSheet($"{pair.Key}: {agent.CharaName}", () => Warp(agent.NavMeshAgent.transform) )); } sheet.SetSheets(list); }
/// <summary> /// 设置模型原点 /// </summary> /// <param name="insertionPoint">如果是0表示项目基点,非零表示观测点。</param> /// <returns></returns> private Transform GetProjectLocationTransform(int insertionPoint) { Transform transform = Transform.Identity; using (IEnumerator <Element> enumerator = new FilteredElementCollector(document).OfClass(typeof(BasePoint)).GetEnumerator()) { while (enumerator.MoveNext()) { BasePoint basePoint = (BasePoint)enumerator.Current; if (basePoint.IsShared == (insertionPoint != 0)) { double num = 0.0; Parameter parameter = basePoint.get_Parameter(BuiltInParameter.BASEPOINT_ANGLETON_PARAM); if (parameter != null) { num = parameter.AsDouble(); } transform = GetTransformFromLocation(basePoint.get_Parameter(BuiltInParameter.BASEPOINT_EASTWEST_PARAM).AsDouble(), basePoint.get_Parameter(BuiltInParameter.BASEPOINT_NORTHSOUTH_PARAM).AsDouble(), basePoint.get_Parameter(BuiltInParameter.BASEPOINT_ELEVATION_PARAM).AsDouble(), -num); } } } ProjectPosition projectPosition = document.ActiveProjectLocation.GetProjectPosition(XYZ.Zero); Transform transformFromLocation = GetTransformFromLocation(projectPosition.EastWest, projectPosition.NorthSouth, projectPosition.Elevation, projectPosition.Angle); return(transform.Inverse * transformFromLocation); }
/// <summary> /// Device coords provider /// </summary> /// <param name="maxMinPoint">MinMax point of entity or entity array</param> /// <param name="stage">Number of splits</param> /// <returns> /// Math.Pow(2, 3 * stage) Elements with center coords distributed gradually in maxMinPoint-limited block. /// MoveUsingNegativeOffsetVector ABSOLUTELY MUST be applied! /// </returns> public static List<Element> GetSplitBlockCollection(BasePoint[] maxMinPoint, int stage) { var resultCollection = new List<Element>(); var dimension = GetDimensions(maxMinPoint); var tmpElementBase = new ElementBase( Math.Round(dimension.X / (Math.Pow(2, stage)), 0), Math.Round(dimension.Y / (Math.Pow(2, stage)), 0), Math.Round(dimension.Z / (Math.Pow(2, stage)), 0) ); var limitX = Math.Abs((int)(maxMinPoint[0].X - maxMinPoint[1].X) / tmpElementBase.XLength); var limitY = Math.Abs((int)(maxMinPoint[0].Y - maxMinPoint[1].Y) / tmpElementBase.YLength); var limitZ = Math.Abs((int)(maxMinPoint[0].Z - maxMinPoint[1].Z) / tmpElementBase.ZLength); var startX = maxMinPoint[0].X; var startY = maxMinPoint[0].Y; var startZ = maxMinPoint[0].Z; for (var z = 0; z < limitZ; z++) for (var y = 0; y < limitY; y++) for (var x = 0; x < limitX; x++) { var center = new BasePoint(startX + (x + 0.5) * tmpElementBase.XLength, startY + (y + 0.5) * tmpElementBase.YLength, startZ + (z + 0.5) * tmpElementBase.ZLength); var element = new Element(center, tmpElementBase.XLength, tmpElementBase.YLength, tmpElementBase.ZLength); resultCollection.Add(element); } return resultCollection; }
public Element ToElement() { BasePoint centerMin = new BasePoint(double.MaxValue, double.MaxValue, double.MaxValue); BasePoint centerMax = new BasePoint(double.MinValue, double.MinValue, double.MinValue); foreach (Element element in Elements) { if (element.Center.IsGreater(centerMax)) { centerMax = element.Center; } if (element.Center.IsLower(centerMin)) { centerMin = element.Center; } } double centerX = (centerMax.X + centerMin.X) / 2; double centerY = (centerMax.Y + centerMin.Y) / 2; double centerZ = (centerMax.Z + centerMin.Z) / 2; BasePoint center = new BasePoint(centerX, centerY, centerZ); double lengthX = centerMax.X - centerMin.X + Elements[0].XLength; double lengthY = centerMax.Y - centerMin.Y + Elements[0].YLength; double lengthZ = centerMax.Z - centerMin.Z + Elements[0].ZLength; Element result = new Element(center, lengthX, lengthY, lengthZ); return(result); }
public Simplex(Tuple <int, Vector <double> >[] edges, RiemannianSpace ambiantSpace) : base(edges) { var directionalVectors = new List <Vector <double> >(); foreach (var item in edges.Skip(1)) { directionalVectors.Add(item.Item2 - BasePoint); } DirectionalVectors = directionalVectors.ToArray(); DimAmbiantSpace = BasePoint.Count(); Parametrization chart = x => { var dir = Matrix <double> .Build.DenseOfColumnVectors(DirectionalVectors); return(dir * x + BasePoint); }; PushForward pushForward = x => { return(Matrix <double> .Build.DenseOfColumnVectors(DirectionalVectors)); }; AmbiantSpace = ambiantSpace; Trivialization = new LocalTrivialization(chart, pushForward, ambiantSpace); }
public BasePointPair(BasePoint point1, BasePoint point2) { (Point1, Point2) = (point1, point2); deltaVV = Point2.VV - Point1.VV; deltaULF = Point2.ULF - Point1.ULF; UnitUlfPerUnitVV = deltaULF / deltaVV; }
//#region ElementBasePro //private ElementBase InitializeElementBasePro(double delta, int stage) //{ // var containmentPrev = double.MinValue; // var difference = 1d; // while (difference > delta) // { // var containment = GetContainmentPercentage(MaxMinPoint, stage); // if (stage > 0) // difference = containment - containmentPrev; // containmentPrev = containment; // stage++; // } // var dimension = GetDimensions(MaxMinPoint); // //var coefficient = GetCoefficient(dimension); // //var result = new ElementBase // // ( // // Math.Round(dimension.X / (Math.Pow(2, stage) * coefficient.X), 0), // // Math.Round(dimension.Y / (Math.Pow(2, stage) * coefficient.Y), 0), // // Math.Round(dimension.Z / (Math.Pow(2, stage) * coefficient.Z), 0) // // ); // var result = new ElementBase //wrong // ( // Math.Round(dimension.X / (Math.Pow(2, stage)), 0), // Math.Round(dimension.Y / (Math.Pow(2, stage)), 0), // Math.Round(dimension.Z / (Math.Pow(2, stage)), 0) // ); // return result; //} //private double GetContainmentPercentage(BasePoint[] maxMinPoint, int stage) //{ // var collection = GetCollection(maxMinPoint, stage); // var containees = 0; // for (var i = 0; i < collection.Count; i++) // { // foreach (var solid in _solid) // { // var brep = new Brep(solid); // PointContainment containment; // brep.GetPointContainment(collection[i].Center.ConverToAcadPoint(), out containment); // if (containment != PointContainment.Inside) // continue; // containees++; // } // } // return (double)containees / collection.Count; //} //private static BasePoint GetCoefficient(BasePoint dimensions) //{ // const int decimals = 1; // var minValue = MathOperations.FindMin(dimensions.X, dimensions.Y, dimensions.Z); // var result = new BasePoint // ( // Math.Round(dimensions.X / minValue, decimals), // Math.Round(dimensions.Y / minValue, decimals), // Math.Round(dimensions.Z / minValue, decimals) // ); // return result; //} //#endregion //private static double Length(Edge edge) //{ // return Math.Sqrt( // edge.Length() // Math.Pow(edge.Vertex2.Point.X - edge.Vertex1.Point.X, 2) + // Math.Pow(edge.Vertex2.Point.Y - edge.Vertex1.Point.X, 2) + // Math.Pow(edge.Vertex2.Point.Z - edge.Vertex1.Point.X, 2) + // ) //} /// <summary> /// Provides collection of all elements bounded by rectangle of MaxMinPoint /// </summary> /// <returns>Collection of all elements</returns> protected List<Element> GetAllElements() { if (_fullCollection == null) _fullCollection = new List<Element>(); else return _fullCollection; var limitX = Math.Abs((int)(MaxMinPoint[0].X - MaxMinPoint[1].X) / _elementBase.XLength); var limitY = Math.Abs((int)(MaxMinPoint[0].Y - MaxMinPoint[1].Y) / _elementBase.YLength); var limitZ = Math.Abs((int)(MaxMinPoint[0].Z - MaxMinPoint[1].Z) / _elementBase.ZLength); var startX = MaxMinPoint[0].X; var startY = MaxMinPoint[0].Y; var startZ = MaxMinPoint[0].Z; for (var z = 0; z < limitZ; z++) for (var y = 0; y < limitY; y++) for (var x = 0; x < limitX; x++) { var center = new BasePoint(startX + (x + 0.5) * _elementBase.XLength, startY + (y + 0.5) * _elementBase.YLength, startZ + (z + 0.5) * _elementBase.ZLength); try { var element = new Element(center, _elementBase, _fullCollection.Count); _fullCollection.Add(element); } catch (System.Exception) { IsSuccessfullConversion = false; return _fullCollection; } } return _fullCollection; }
/// <summary> /// Projects this vector on the given plane /// </summary> public Vector ProjectOntoPlane(Plane plane) { //find the line in the plane and then project this line onto it Point newBasePoint = BasePoint.ProjectOntoPlane(plane); Point newEndPoint = EndPoint.ProjectOntoPlane(plane); return(new Vector(newBasePoint, newEndPoint)); }
/// <summary> /// Gets the position of the BasePoint. /// </summary> /// <param name="basePoint"></param> /// <returns></returns> public static XYZ GetPosition(this BasePoint basePoint) { #if REVIT_2020 return(basePoint.Position); #else return(basePoint.get_BoundingBox(null).Min); #endif }
public static dynamic GetTSObject(BasePoint dynObject) { if (dynObject is null) { return(null); } return(dynObject.teklaObject); }
private void SetCenterVector(Point3d OriginPoint, double zr) { this.TZRotation += zr; Point3d position = new Point3d(this.XOrigin, this.YOrigin, this.ZOrigin); position = (OriginPoint == Point3d.Origin) ? position : position.TransformBy(Matrix3d.Displacement(new Vector3d(OriginPoint.X, OriginPoint.Y, OriginPoint.Z))); position = position.TransformBy(Matrix3d.Rotation(zr / 180 * System.Math.PI, Vector3d.ZAxis, OriginPoint)); this.TXOrigin = position.X; this.TYOrigin = position.Y; this.TZOrigin = position.Z; Vector3d BaseVector = new Vector3d();//定位向量 if (BasePoint == 1) { BaseVector = new Vector3d(-Length / 2, -Width / 2, -Thickness / 2); } else if (BasePoint == 2) { BaseVector = new Vector3d(-Length / 2, -Width / 2, Thickness / 2); } else if (BasePoint == 3) { BaseVector = new Vector3d(-Length / 2, Width / 2, -Thickness / 2); } else if (BasePoint == 4) { BaseVector = new Vector3d(-Length / 2, Width / 2, Thickness / 2); } else if (BasePoint == 5) { BaseVector = new Vector3d(Length / 2, Width / 2, -Thickness / 2); } else if (BasePoint == 6) { BaseVector = new Vector3d(Length / 2, Width / 2, Thickness / 2); } else if (BasePoint == 7) { BaseVector = new Vector3d(Length / 2, -Width / 2, -Thickness / 2); } else if (BasePoint == 8) { BaseVector = new Vector3d(Length / 2, -Width / 2, Thickness / 2); } else { throw new System.Exception("Unknown Basepoint" + BasePoint.ToString()); } Vector3d MoveVector = MathHelper.GetRotateVector(BaseVector, TXRotation, TYRotation, TZRotation); Vector3d DimVector = new Vector3d(TXOrigin, TYOrigin, TZOrigin); CenterVector = -MoveVector + DimVector; }
/// <summary> /// Gets the shared position of the BasePoint. /// </summary> /// <param name="basePoint"></param> /// <returns></returns> public static XYZ GetSharedPosition(this BasePoint basePoint) { #if REVIT_2020 return(basePoint.SharedPosition); #else var position = basePoint.Document.ActiveProjectLocation.GetProjectPosition(GetPosition(basePoint)); return(new XYZ(position.EastWest, position.NorthSouth, position.Elevation)); #endif }
public Element(BasePoint center, double xLength, double yLength, double zLength) : base(xLength, yLength, zLength) { Center = center; XLength = xLength; YLength = yLength; ZLength = zLength; ResetNeighbours(); }
public Element(BasePoint center, ElementBase elementBase) : base(elementBase.XLength, elementBase.YLength, elementBase.ZLength) { Center = center; XLength = elementBase.XLength; YLength = elementBase.YLength; ZLength = elementBase.ZLength; ResetNeighbours(); }
private static BasePoint GetDimensions(BasePoint[] maxMinPoint) { var result = new BasePoint ( maxMinPoint[1].X - maxMinPoint[0].X, maxMinPoint[1].Y - maxMinPoint[0].Y, maxMinPoint[1].Z - maxMinPoint[0].Z ); return result; }
public int?GetElementNoByCenter(BasePoint center) { for (int i = 0; i < Elements.Count; i++) { if (Elements[i].Center.Equals(center)) { return(i); } } return(null); }
/// <summary> /// Gets the survey point for the document. /// </summary> /// <param name="doc">The document from which to get the survey point.</param> /// <returns>The survey point of the document.</returns> public static BasePoint GetSurveyPoint(Document doc) { #if REVIT_2021 return(BasePoint.GetSurveyPoint(doc)); #else using (var collector = new FilteredElementCollector(doc)) { var pointCollector = collector.OfCategory(BuiltInCategory.OST_SharedBasePoint); return(pointCollector.FirstElement() as BasePoint); } #endif }
public static BasePoint InitNegativeOffsetVector(BasePoint minpoint) { var x = minpoint.X < 0 ? minpoint.X : 0; var y = minpoint.Y < 0 ? minpoint.Y : 0; var z = minpoint.Z < 0 ? minpoint.Z : 0; if (x < 0 || y < 0 || z < 0) { return(new BasePoint(-x, -y, -z)); } return(null); }
public static void EntityAreEqual(Entity Entity, EntityEntity EntityEntity, BasePoint BasePoint, Ep Ep) { Assert.Equal(Entity.EntityExpirations.First().EntityExpirationGuid, EntityEntity.Id); Assert.Equal(Entity.Number, EntityEntity.Number); Assert.Equal(Entity.EntityExpirations.First().ValidFrom, EntityEntity.ValidFrom); Assert.Equal(Entity.EntityExpirations.First().ValidTo, EntityEntity.ValidTo); Assert.Equal(BasePoint.Systematic.ToEntitySystematic(), EntityEntity.Systematic); var Place = EntityEntity.EntityPlaces.First(); EtDirectPlaceAreEqual(Place, Ep); }
public bool Equals(Line other) { if (other is null) { return(false); } bool linesAreParallel = this.IsParallelTo(other); bool basePointIsOnLine1 = BasePoint.IsOnLine(other); bool basePointIsOnLine2 = other.BasePoint.IsOnLine(this); return(linesAreParallel && (basePointIsOnLine1 || basePointIsOnLine2)); }
/// <summary> /// Absolute MUST to perform before any computation and element analysis /// </summary> public ElementCollection SetNeighbourhoodRelations() { for (int i = 0; i < Elements.Count; i++) { BasePoint tmpCenter = Elements[i].Center; tmpCenter.X = Elements[i].Center.X + Elements[i].XLength; if (GetElementNoByCenter(tmpCenter) != null) { Elements[i].NeighbourRight = i; } tmpCenter = Elements[i].Center; tmpCenter.X = Elements[i].Center.X - Elements[i].XLength; if (GetElementNoByCenter(tmpCenter) != null) { Elements[i].NeighbourLeft = i; } tmpCenter = Elements[i].Center; tmpCenter.Y = Elements[i].Center.Y + Elements[i].YLength; if (GetElementNoByCenter(tmpCenter) != null) { Elements[i].NeighbourBack = i; } tmpCenter = Elements[i].Center; tmpCenter.Y = Elements[i].Center.Y - Elements[i].YLength; if (GetElementNoByCenter(tmpCenter) != null) { Elements[i].NeighbourFront = i; } tmpCenter = Elements[i].Center; tmpCenter.Z = Elements[i].Center.Z + Elements[i].ZLength; if (GetElementNoByCenter(tmpCenter) != null) { Elements[i].NeighbourTop = i; } tmpCenter = Elements[i].Center; tmpCenter.Z = Elements[i].Center.Z - Elements[i].ZLength; if (GetElementNoByCenter(tmpCenter) != null) { Elements[i].NeighbourBottom = i; } } return(this); }
public int CompareTo(PointInfo other) { var basePointComparison = BasePoint.CompareTo(other.BasePoint); if (basePointComparison != 0) { return(basePointComparison); } var fanComparison = TotalFan.CompareTo(other.TotalFan); if (fanComparison != 0) { return(fanComparison); } return(Fu.CompareTo(other.Fu)); }
/// <summary> /// Converts collection to single element /// </summary> /// <returns>Element</returns> public static Element ToElement(this List <Element> elements) { var minX = double.MaxValue; var minY = double.MaxValue; var minZ = double.MaxValue; var maxX = double.MinValue; var maxY = double.MinValue; var maxZ = double.MinValue; foreach (var element in elements) { if (element.X1 < minX) { minX = element.X1; } if (element.Y1 < minY) { minY = element.Y1; } if (element.Z1 < minZ) { minZ = element.Z1; } if (element.X2 > maxX) { maxX = element.X2; } if (element.Y2 > maxY) { maxY = element.Y2; } if (element.Z2 > maxZ) { maxZ = element.Z2; } } var centerX = (minX + maxX) / 2; var centerY = (minY + maxY) / 2; var centerZ = (minZ + maxZ) / 2; var center = new BasePoint(centerX, centerY, centerZ); // Todo : decide if it is necessary to set in this constructor index return(new Element(center, maxX - minX, maxY - minY, maxZ - minZ, elements[0].Material)); }
public Result Execute(ExternalCommandData commandData, ref string message, ElementSet elements) { Application app = commandData.Application.Application; UIDocument uidoc = commandData.Application.ActiveUIDocument; Document doc = uidoc.Document; // Get Project Base Point (PBP) and it's parameters. FilteredElementCollector collector = new FilteredElementCollector(doc).OfCategory(BuiltInCategory.OST_ProjectBasePoint); BasePoint element = (BasePoint)collector.ToElements().FirstOrDefault(); double angle = element.get_Parameter(BuiltInParameter.BASEPOINT_ANGLETON_PARAM).AsDouble(); double EW = element.get_Parameter(BuiltInParameter.BASEPOINT_EASTWEST_PARAM).AsDouble(); double NS = element.get_Parameter(BuiltInParameter.BASEPOINT_NORTHSOUTH_PARAM).AsDouble(); double elevation = element.get_Parameter(BuiltInParameter.BASEPOINT_ELEVATION_PARAM).AsDouble(); // Get the coordinates of the Project Base Point (PBP) in case it's moved unclipped. XYZ PBP = element.get_BoundingBox(null).Max; // Calculating the distances between internal origo and shared origo. EW and NS is measured in the directions given by the angle to true north. double x = EW * Math.Cos(angle) - NS * Math.Sin(angle) - PBP.X; double y = NS * Math.Cos(angle) + EW * Math.Sin(angle) - PBP.Y; double z = elevation - PBP.Z; XYZ SharedOrigo = new XYZ(-x, -y, -z); Line axis = Line.CreateUnbound(SharedOrigo, new XYZ(0, 0, 1)); Element selectedLink; try { selectedLink = doc.GetElement(uidoc.Selection.PickObject(ObjectType.Element, "Pick a link to move from Origin (internal) to Surveypoint.")); } catch(Autodesk.Revit.Exceptions.OperationCanceledException) { return Result.Cancelled; } if (selectedLink == null) return Result.Failed; using (Transaction t1 = new Transaction(doc, "Move link from internal origin to survey point")) { t1.Start(); selectedLink.Location.Move(SharedOrigo); selectedLink.Location.Rotate(axis, angle); t1.Commit(); } return Result.Succeeded; }
/// <summary> /// Converts array of two base points to element. /// </summary> /// <param name="maxMinPoint">Array of front-bottom left and top-righ-back points of the element.</param> /// <returns>Elements limited with passed front-bottom left and top-righ-back points.</returns> public static Element ToElement(this BasePoint[] maxMinPoint) { if (maxMinPoint.Length > 2) { throw new ArgumentException("maxMinPoint"); } var center = new BasePoint(maxMinPoint[0].X - (maxMinPoint[0].X - maxMinPoint[1].X) / 2, maxMinPoint[0].Y - (maxMinPoint[0].Y - maxMinPoint[1].Y) / 2, maxMinPoint[0].Z - (maxMinPoint[0].Z - maxMinPoint[1].Z) / 2); var xLength = (maxMinPoint[0].X - maxMinPoint[1].X); var yLength = (maxMinPoint[0].Y - maxMinPoint[1].Y); var zLength = (maxMinPoint[0].Z - maxMinPoint[1].Z); return(new Element(center, xLength, yLength, zLength)); }
/// <summary> /// Compute the Eastings, Northings, OrthogonalHeight from the selected SiteTransformationBasis /// </summary> /// <param name="doc">The document</param> /// <param name="wcsBasis">The selected coordinate base</param> /// <returns>A Tuple for Eastings, Northings, and OrthogonalHeight</returns> public static (double eastings, double northings, double orthogonalHeight) GeoReferenceInformation(Document doc, SiteTransformBasis wcsBasis) { double eastings = 0.0; double northings = 0.0; double orthogonalHeight = 0.0; BasePoint surveyPoint = BasePoint.GetSurveyPoint(doc); BasePoint projectBasePoint = BasePoint.GetProjectBasePoint(doc); switch (wcsBasis) { case SiteTransformBasis.Internal: northings = surveyPoint.SharedPosition.Y - surveyPoint.Position.Y; eastings = surveyPoint.SharedPosition.X - surveyPoint.Position.X; orthogonalHeight = surveyPoint.SharedPosition.Z - surveyPoint.Position.Z; break; case SiteTransformBasis.Project: northings = projectBasePoint.SharedPosition.Y; eastings = projectBasePoint.SharedPosition.X; orthogonalHeight = projectBasePoint.SharedPosition.Z; break; case SiteTransformBasis.Shared: northings = 0.0; eastings = 0.0; orthogonalHeight = 0.0; break; case SiteTransformBasis.Site: northings = surveyPoint.SharedPosition.Y; eastings = surveyPoint.SharedPosition.X; orthogonalHeight = surveyPoint.SharedPosition.Z; break; default: northings = 0.0; eastings = 0.0; orthogonalHeight = 0.0; break; } return(eastings, northings, orthogonalHeight); }
private static IEnumerable <VectorNd> CreateClusterAround( BasePoint pt, double radius, int count) { var cluster = new List <VectorNd>(); var rnd = new Random(); var range = new Interval(-radius, radius); for (var i = 0; i < count; i++) { var x = pt.X + range.RemapFromUnit(rnd.NextDouble()); var y = pt.Y + range.RemapFromUnit(rnd.NextDouble()); var z = pt.Z + range.RemapFromUnit(rnd.NextDouble()); cluster.Add(new VectorNd(x, y, z)); } return(cluster); }
public Either <Null, Point, LineSegment> IntersectWithSegment(LineSegment lineSegment) { return(new Line(this).IntersectWithSegment(lineSegment).Switch <Either <Null, Point, LineSegment> > ( @null => @null, point => { if (point == BasePoint || BasePoint.DirectionTo(point) == Direction) { return point; } return Null.Instance; }, segment => { var points = segment.EndPoints .Where(point => { var towardsEndPoint = new Direction(BasePoint, point); return towardsEndPoint == Direction || point == BasePoint; }) .ToList(); if (points.Count == 2) { return segment; } if (points.Count == 1) { var segmentPoint = points[0]; if (segmentPoint != BasePoint) { return new LineSegment(BasePoint, segmentPoint); } return segmentPoint; } return Null.Instance; } )); }
/// <summary> /// Returns minimal and maximal Bases point /// </summary> /// <returns>Array of 2 elements where [0] is Max and [1] is Min</returns> public static BasePoint[] GetMaxMinPoint(IEnumerable<Entity> solids) { var result = new BasePoint[2]; var xMax = double.MinValue; var yMax = double.MinValue; var zMax = double.MinValue; var xMin = double.MaxValue; var yMin = double.MaxValue; var zMin = double.MaxValue; foreach (var solid in solids) { try { var brep = new Brep(solid); using (brep) { foreach (var edg in brep.Edges) { var tmp = CastHelper.ConvertToBasePoint(edg.Vertex1.Point); if (tmp.X > xMax) xMax = tmp.X; if (tmp.X < xMin) xMin = tmp.X; if (tmp.Y > yMax) yMax = tmp.Y; if (tmp.Y < yMin) yMin = tmp.Y; if (tmp.Z > zMax) zMax = tmp.Z; if (tmp.Z < zMin) zMin = tmp.Z; } } } catch (Autodesk.AutoCAD.BoundaryRepresentation.Exception) { Debug.WriteLine("Exception occured"); } } result[0] = new BasePoint(xMin, yMin, zMin); result[1] = new BasePoint(xMax, yMax, zMax); return result; }
private void UpdateStakeOutByDataGridView() { string nameBasePoint = ""; BasePoint bp = null; for (int i = 0; i < this.dataGridView_StakeOut.RowCount; i++) { if (this.dataGridView_StakeOut[2, i].Value != null) { nameBasePoint = this.dataGridView_StakeOut[2, i].Value.ToString(); bp = this.basePoints.Find(x => x.Name.Contains(nameBasePoint)); this.currentParcel.StakeOutParcelPoints[i].PointStation = bp; } this.currentParcel.StakeOutParcelPoints[i].Visible = (bool)this.dataGridView_StakeOut[0, i].Value; this.dataGridView_StakeOut.Rows[(int)this.dataGridView_StakeOut.CurrentRow.Index].Selected = true; this.currentParcel.StakeOutParcelPoints[i].Regen(); } }
public IMapEvent GetEventInRect(BasePoint loc, BasePoint size) { return this.GetEventInRect(new Rectangle(loc.X, loc.Y, size.X, size.Y)); }
public bool HandleEvent(BaseCharacter player, ActivationTypes activation) { BasePoint pos = new BasePoint(player.MapLocation.X, player.MapLocation.Y); if (activation == ActivationTypes.Activate || activation == ActivationTypes.Collision) { BasePoint newpt = player.GetLookPoint(); pos = new BasePoint(pos.X + newpt.X, pos.Y + newpt.Y); } IMapEvent mapevent = GetEvent(new MapPoint(pos.X, pos.Y)); if (mapevent != null && (mapevent.Direction == Directions.Any || mapevent.Direction == player.Direction) && mapevent.Activation == activation) { mapevent.Trigger(player); return true; } return false; }
private void Stream( ArrayList data, BasePoint basePt ) { data.Add( new Snoop.Data.ClassSeparator( typeof( BasePoint ) ) ); data.Add( new Snoop.Data.Bool( "Is shared", basePt.IsShared ) ); }
protected BasePoint(BasePoint other) { this.x = other.X; this.y = other.Y; }