Beispiel #1
0
        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);
        }
Beispiel #5
0
        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);
        }
Beispiel #6
0
 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
        }
Beispiel #10
0
 public static dynamic GetTSObject(BasePoint dynObject)
 {
     if (dynObject is null)
     {
         return(null);
     }
     return(dynObject.teklaObject);
 }
Beispiel #11
0
        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
        }
Beispiel #13
0
 public Element(BasePoint center, double xLength, double yLength, double zLength)
     : base(xLength, yLength, zLength)
 {
     Center  = center;
     XLength = xLength;
     YLength = yLength;
     ZLength = zLength;
     ResetNeighbours();
 }
Beispiel #14
0
 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
        }
Beispiel #18
0
        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);
        }
Beispiel #20
0
        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);
        }
Beispiel #22
0
        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));
        }
Beispiel #23
0
        /// <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));
        }
Beispiel #24
0
        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;
        }
Beispiel #25
0
        /// <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));
        }
Beispiel #26
0
        /// <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);
        }
Beispiel #27
0
        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);
        }
Beispiel #28
0
        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;
        }
Beispiel #30
0
        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();
            }
        }
Beispiel #31
0
 public IMapEvent GetEventInRect(BasePoint loc, BasePoint size)
 {
     return this.GetEventInRect(new Rectangle(loc.X, loc.Y, size.X, size.Y));
 }
Beispiel #32
0
        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;
	}