コード例 #1
0
 /// <summary>
 /// Initializes a new instance of the <c>LinearDimension</c> class.
 /// </summary>
 /// <param name="firstPoint">First reference <see cref="Vector2">point</see> of the dimension.</param>
 /// <param name="secondPoint">Second reference <see cref="Vector2">point</see> of the dimension.</param>
 /// <param name="offset">Distance between the mid point reference line and the dimension line.</param>
 /// <param name="rotation">Rotation in degrees of the dimension line.</param>
 /// <param name="style">The <see cref="DimensionStyle">style</see> to use with the dimension.</param>
 /// <remarks>The reference points define the distance to be measure.</remarks>
 public LinearDimension(Vector2 firstPoint, Vector2 secondPoint, double offset, double rotation, DimensionStyle style)
     : base(DimensionType.Linear)
 {
     this.firstRefPoint  = firstPoint;
     this.secondRefPoint = secondPoint;
     this.offset         = offset;
     this.rotation       = MathHelper.NormalizeAngle(rotation);
     if (style == null)
     {
         throw new ArgumentNullException(nameof(style));
     }
     this.Style = style;
 }
コード例 #2
0
        /// <summary>
        /// Initializes a new instance of the <c>Angular2LineDimension</c> class.
        /// </summary>
        /// <param name="firstLine">First <see cref="Line">line</see> that defines the angle to measure.</param>
        /// <param name="secondLine">Second <see cref="Line">line</see> that defines the angle to measure.</param>
        /// <param name="offset">Distance between the center point and the dimension line.</param>
        /// <param name="style">The <see cref="DimensionStyle">style</see> to use with the dimension.</param>
        public Angular2LineDimension(Line firstLine, Line secondLine, double offset, Vector3 normal, DimensionStyle style)
            : base(DimensionType.Angular)
        {
            if (firstLine == null)
            {
                throw new ArgumentNullException(nameof(firstLine));
            }
            if (secondLine == null)
            {
                throw new ArgumentNullException(nameof(secondLine));
            }

            if (Vector3.AreParallel(firstLine.Direction, secondLine.Direction))
            {
                throw new ArgumentException("The two lines that define the dimension are parallel.");
            }

            IList <Vector3> ocsPoints =
                MathHelper.Transform(
                    new[]
            {
                firstLine.StartPoint,
                firstLine.EndPoint,
                secondLine.StartPoint,
                secondLine.EndPoint
            },
                    normal, CoordinateSystem.World, CoordinateSystem.Object);

            startFirstLine  = new Vector2(ocsPoints[0].X, ocsPoints[0].Y);
            endFirstLine    = new Vector2(ocsPoints[1].X, ocsPoints[1].Y);
            startSecondLine = new Vector2(ocsPoints[2].X, ocsPoints[2].Y);
            endSecondLine   = new Vector2(ocsPoints[3].X, ocsPoints[3].Y);
            if (offset < 0)
            {
                throw new ArgumentOutOfRangeException(nameof(offset), "The offset value must be equal or greater than zero.");
            }
            this.offset = offset;

            if (style == null)
            {
                throw new ArgumentNullException(nameof(style));
            }
            Style     = style;
            Normal    = normal;
            Elevation = ocsPoints[0].Z;
            Update();
        }
コード例 #3
0
        /// <summary>
        /// Initializes a new instance of the <c>Angular3PointDimension</c> class.
        /// </summary>
        /// <param name="centerPoint">Center of the angle arc to measure.</param>
        /// <param name="startPoint">Angle start point.</param>
        /// <param name="endPoint">Angle end point.</param>
        /// <param name="offset">Distance between the center point and the dimension line.</param>
        /// <param name="style">The <see cref="DimensionStyle">style</see> to use with the dimension.</param>
        public Angular3PointDimension(Vector2 centerPoint, Vector2 startPoint, Vector2 endPoint, double offset, DimensionStyle style)
            : base(DimensionType.Angular3Point)
        {
            Vector2 dir1 = startPoint - centerPoint;
            Vector2 dir2 = endPoint - centerPoint;

            if (Vector2.AreParallel(dir1, dir2))
            {
                throw new ArgumentException("The two lines that define the dimension are parallel.");
            }
            this.center = centerPoint;
            this.start  = startPoint;
            this.end    = endPoint;
            if (offset < 0)
            {
                throw new ArgumentOutOfRangeException(nameof(offset), "The offset value must be equal or greater than zero.");
            }
            this.offset = offset;
            if (style == null)
            {
                throw new ArgumentNullException(nameof(style));
            }
            this.Style = style;
            this.Update();
        }
コード例 #4
0
        /// <summary>
        /// Initializes a new instance of the <c>OrdinateDimension</c> class.
        /// </summary>
        /// <param name="origin">Origin <see cref="Vector2">point</see> in local coordinates of the ordinate dimension.</param>
        /// <param name="featurePoint">Base location <see cref="Vector2">point</see> in local coordinates of the ordinate dimension.</param>
        /// <param name="leaderEndPoint">Leader end <see cref="Vector2">point</see> in local coordinates of the ordinate dimension</param>
        /// <param name="style">The <see cref="DimensionStyle">style</see> to use with the dimension.</param>
        /// <remarks>
        /// Uses the difference between the feature location and the leader endpoint to determine whether it is an X or a Y ordinate dimension.
        /// If the difference in the Y ordinate is greater, the dimension measures the X ordinate. Otherwise, it measures the Y ordinate.
        /// </remarks>
        public OrdinateDimension(Vector2 origin, Vector2 featurePoint, Vector2 leaderEndPoint, DimensionStyle style)
            : base(DimensionType.Ordinate)
        {
            this.defPoint     = origin;
            this.firstPoint   = featurePoint;
            this.secondPoint  = leaderEndPoint;
            this.textRefPoint = leaderEndPoint;
            Vector2 vec = leaderEndPoint - featurePoint;

            this.axis     = vec.Y > vec.X ? OrdinateDimensionAxis.X : OrdinateDimensionAxis.Y;
            this.rotation = 0.0;
            if (style == null)
            {
                throw new ArgumentNullException(nameof(style));
            }
            this.Style = style;
        }
コード例 #5
0
        /// <summary>
        /// Initializes a new instance of the <c>Angular2LineDimension</c> class.
        /// </summary>
        /// <param name="startFirstLine">Start <see cref="Vector2">point</see> of the first line that defines the angle to measure.</param>
        /// <param name="endFirstLine">End <see cref="Vector2">point</see> of the first line that defines the angle to measure.</param>
        /// <param name="startSecondLine">Start <see cref="Vector2">point</see> of the second line that defines the angle to measure.</param>
        /// <param name="endSecondLine">End <see cref="Vector2">point</see> of the second line that defines the angle to measure.</param>
        /// <param name="offset">Distance between the center point and the dimension line.</param>
        /// <param name="style">The <see cref="DimensionStyle">style</see> to use with the dimension.</param>
        public Angular2LineDimension(Vector2 startFirstLine, Vector2 endFirstLine, Vector2 startSecondLine, Vector2 endSecondLine, double offset, DimensionStyle style)
            : base(DimensionType.Angular)
        {
            Vector2 dir1 = endFirstLine - startFirstLine;
            Vector2 dir2 = endSecondLine - startSecondLine;

            if (Vector2.AreParallel(dir1, dir2))
            {
                throw new ArgumentException("The two lines that define the dimension are parallel.");
            }

            this.startFirstLine  = startFirstLine;
            this.endFirstLine    = endFirstLine;
            this.startSecondLine = startSecondLine;
            this.endSecondLine   = endSecondLine;

            if (offset < 0)
            {
                throw new ArgumentOutOfRangeException(nameof(offset), "The offset value must be equal or greater than zero.");
            }
            this.offset = offset;

            if (style == null)
            {
                throw new ArgumentNullException(nameof(style));
            }
            Style = style;
            Update();
        }
コード例 #6
0
 /// <summary>
 /// Initializes a new instance of the <c>AlignedDimension</c> class.
 /// </summary>
 /// <param name="firstPoint">First reference <see cref="Vector3">point</see> of the dimension.</param>
 /// <param name="secondPoint">Second reference <see cref="Vector3">point</see> of the dimension.</param>
 /// <param name="offset">Distance between the reference line and the dimension line.</param>
 /// <param name="style">The <see cref="DimensionStyle">style</see> to use with the dimension.</param>
 /// <remarks>The reference points define the distance to be measure.</remarks>
 public AlignedDimension(Vector3 firstPoint, Vector3 secondPoint, double offset, DimensionStyle style)
     : base(DimensionType.Aligned)
 {
     this.firstRefPoint  = firstPoint;
     this.secondRefPoint = secondPoint;
     this.offset         = offset;
     if (style == null)
     {
         throw new ArgumentNullException("style", "The Dimension style cannot be null.");
     }
     this.style = style;
 }
コード例 #7
0
 /// <summary>
 /// Initializes a new instance of the <c>OrdinateDimension</c> class.
 /// </summary>
 /// <param name="origin">Origin <see cref="Vector2">point</see> of the ordinate dimension.</param>
 /// <param name="featurePoint">Base location <see cref="Vector2">point</see> in local coordinates of the ordinate dimension.</param>
 /// <param name="length">Length of the dimension line.</param>
 /// <param name="axis">Length of the dimension line.</param>
 /// <param name="style">The <see cref="DimensionStyle">style</see> to use with the dimension.</param>
 /// <remarks>The local coordinate system of the dimension is defined by the dimension normal and the rotation value.</remarks>
 public OrdinateDimension(Vector2 origin, Vector2 featurePoint, double length, OrdinateDimensionAxis axis, DimensionStyle style)
     : this(origin, featurePoint, length, axis, 0.0, style)
 {
 }
コード例 #8
0
 /// <summary>
 /// Initializes a new instance of the <c>Angular2LineDimension</c> class.
 /// </summary>
 /// <param name="startFirstLine">Start <see cref="Vector2">point</see> of the first line that defines de angle to measure.</param>
 /// <param name="endFirstLine">End <see cref="Vector2">point</see> of the first line that defines de angle to measure.</param>
 /// <param name="startSecondLine">Start <see cref="Vector2">point</see> of the second line that defines de angle to measure.</param>
 /// <param name="endSecondLine">End <see cref="Vector2">point</see> of the second line that defines de angle to measure.</param>
 /// <param name="offset">Distance between the center point and the dimension line.</param>
 /// <param name="style">The <see cref="DimensionStyle">style</see> to use with the dimension.</param>
 public Angular2LineDimension(Vector2 startFirstLine, Vector2 endFirstLine, Vector2 startSecondLine, Vector2 endSecondLine, double offset, DimensionStyle style)
     : this(new Vector3(startFirstLine.X, startFirstLine.Y, 0.0), new Vector3(endFirstLine.X, endFirstLine.Y, 0.0), new Vector3(startSecondLine.X, startSecondLine.Y, 0.0), new Vector3(endSecondLine.X, endSecondLine.Y, 0.0), offset, style)
 {
 }
コード例 #9
0
 /// <summary>
 /// Initializes a new instance of the <c>Angular2LineDimension</c> class.
 /// </summary>
 /// <param name="startFirstLine">Start <see cref="Vector3">point</see> of the first line that defines de angle to measure.</param>
 /// <param name="endFirstLine">End <see cref="Vector3">point</see> of the first line that defines de angle to measure.</param>
 /// <param name="startSecondLine">Start <see cref="Vector3">point</see> of the second line that defines de angle to measure.</param>
 /// <param name="endSecondLine">End <see cref="Vector3">point</see> of the second line that defines de angle to measure.</param>
 /// <param name="offset">Distance between the center point and the dimension line.</param>
 /// <param name="style">The <see cref="DimensionStyle">style</see> to use with the dimension.</param>
 public Angular2LineDimension(Vector3 startFirstLine, Vector3 endFirstLine, Vector3 startSecondLine, Vector3 endSecondLine, double offset, DimensionStyle style)
     : base(DimensionType.Angular)
 {
     this.startFirstLine  = startFirstLine;
     this.endFirstLine    = endFirstLine;
     this.startSecondLine = startSecondLine;
     this.endSecondLine   = endSecondLine;
     this.offset          = offset;
     if (style == null)
     {
         throw new ArgumentNullException("style", "The Dimension style cannot be null.");
     }
     this.style  = style;
     this.normal = this.CaluculateNormal();
 }
コード例 #10
0
 /// <summary>
 /// Initializes a new instance of the <c>LinearDimension</c> class.
 /// </summary>
 /// <param name="referenceLine">Reference <see cref="Line">line</see> of the dimension.</param>
 /// <param name="offset">Distance between the reference line and the dimension line.</param>
 /// <param name="rotation">Rotation in degrees of the dimension line.</param>
 /// <param name="style">The <see cref="DimensionStyle">style</see> to use with the dimension.</param>
 /// <remarks>The reference points define the distance to be measure.</remarks>
 public LinearDimension(Line referenceLine, double offset, double rotation, DimensionStyle style)
     : this(referenceLine, offset, rotation, Vector3.UnitZ, style)
 {
 }
コード例 #11
0
        /// <summary>
        /// Initializes a new instance of the <c>LinearDimension</c> class.
        /// </summary>
        /// <param name="referenceLine">Reference <see cref="Line">line</see> of the dimension.</param>
        /// <param name="offset">Distance between the reference line and the dimension line.</param>
        /// <param name="rotation">Rotation in degrees of the dimension line.</param>
        /// <param name="normal">Normal vector of the plane where the dimension is defined.</param>
        /// <param name="style">The <see cref="DimensionStyle">style</see> to use with the dimension.</param>
        /// <remarks>The reference line define the distance to be measure.</remarks>
        public LinearDimension(Line referenceLine, double offset, double rotation, Vector3 normal, DimensionStyle style)
            : base(DimensionType.Linear)
        {
            if (referenceLine == null)
            {
                throw new ArgumentNullException(nameof(referenceLine));
            }

            IList <Vector3> ocsPoints = MathHelper.Transform(
                new List <Vector3> {
                referenceLine.StartPoint, referenceLine.EndPoint
            }, normal, CoordinateSystem.World, CoordinateSystem.Object);

            this.firstRefPoint  = new Vector2(ocsPoints[0].X, ocsPoints[0].Y);
            this.secondRefPoint = new Vector2(ocsPoints[1].X, ocsPoints[1].Y);

            if (offset < 0)
            {
                throw new ArgumentOutOfRangeException(nameof(offset), "The offset value must be equal or greater than zero.");
            }
            this.offset   = offset;
            this.rotation = MathHelper.NormalizeAngle(rotation);

            if (style == null)
            {
                throw new ArgumentNullException(nameof(style));
            }
            this.Style     = style;
            this.Normal    = normal;
            this.Elevation = ocsPoints[0].Z;
            this.Update();
        }
コード例 #12
0
 /// <summary>
 /// Initializes a new instance of the <c>LinearDimension</c> class.
 /// </summary>
 /// <param name="firstPoint">First reference <see cref="Vector2">point</see> of the dimension.</param>
 /// <param name="secondPoint">Second reference <see cref="Vector2">point</see> of the dimension.</param>
 /// <param name="offset">Distance between the mid point reference line and the dimension line.</param>
 /// <param name="rotation">Rotation in degrees of the dimension line.</param>
 /// <param name="style">The <see cref="DimensionStyle">style</see> to use with the dimension.</param>
 /// <remarks>The reference points define the distance to be measure.</remarks>
 public LinearDimension(Vector2 firstPoint, Vector2 secondPoint, double offset, double rotation, DimensionStyle style)
     : base(DimensionType.Linear)
 {
     this.firstRefPoint  = firstPoint;
     this.secondRefPoint = secondPoint;
     if (offset < 0)
     {
         throw new ArgumentOutOfRangeException(nameof(offset), "The offset value must be equal or greater than zero.");
     }
     this.offset   = offset;
     this.rotation = MathHelper.NormalizeAngle(rotation);
     if (style == null)
     {
         throw new ArgumentNullException(nameof(style));
     }
     this.Style = style;
     this.Update();
 }
コード例 #13
0
 /// <summary>
 /// Initializes a new instance of the <c>DiametricDimension</c> class.
 /// </summary>
 /// <param name="centerPoint">Center <see cref="Vector2">point</see> of the circunference.</param>
 /// <param name="referencePoint"><see cref="Vector2">Point</see> on circle or arc.</param>
 /// <param name="offset">Distance between the reference point and the dimension text</param>
 /// <param name="style">The <see cref="DimensionStyle">style</see> to use with the dimension.</param>
 /// <remarks>The center point and the definition point define the distance to be measure.</remarks>
 public DiametricDimension(Vector2 centerPoint, Vector2 referencePoint, double offset, DimensionStyle style)
     : this(new Vector3(centerPoint.X, centerPoint.Y, 0.0), new Vector3(referencePoint.X, referencePoint.Y, 0.0), offset, style)
 {
 }
コード例 #14
0
 /// <summary>
 ///  Creates a Leader geometry object
 /// </summary>
 /// <param name="text"></param>
 /// <param name="plane"></param>
 /// <param name="dimstyle"></param>
 /// <param name="points"></param>
 /// <returns></returns>
 /// <since>6.0</since>
 public static Leader Create(string text, Plane plane, DimensionStyle dimstyle, Point3d[] points)
 {
     return(CreateWithRichText(AnnotationBase.PlainTextToRtf(text), plane, dimstyle, points));
 }
コード例 #15
0
        protected virtual DimensionStyle OnDimensionStyleChangedEvent(DimensionStyle oldStyle, DimensionStyle newStyle)
        {
            DimensionStyleChangedEventHandler ae = this.DimensionStyleChanged;

            if (ae != null)
            {
                TableObjectChangedEventArgs <DimensionStyle> eventArgs = new TableObjectChangedEventArgs <DimensionStyle>(oldStyle, newStyle);
                ae(this, eventArgs);
                return(eventArgs.NewValue);
            }
            return(newStyle);
        }
コード例 #16
0
 /// <summary>
 /// Initializes a new instance of the <c>Angular2LineDimension</c> class.
 /// </summary>
 /// <param name="firstLine">First <see cref="Line">line</see> that defines the angle to measure.</param>
 /// <param name="secondLine">Second <see cref="Line">line</see> that defines the angle to measure.</param>
 /// <param name="offset">Distance between the center point and the dimension line.</param>
 /// <param name="style">The <see cref="DimensionStyle">style</see> to use with the dimension.</param>
 public Angular2LineDimension(Line firstLine, Line secondLine, double offset, DimensionStyle style)
     : this(firstLine.StartPoint, firstLine.EndPoint, secondLine.StartPoint, secondLine.EndPoint, offset, style)
 {
 }
コード例 #17
0
 /// <summary>
 /// Initializes a new instance of the <c>AlignedDimension</c> class.
 /// </summary>
 /// <param name="firstPoint">First reference <see cref="Vector2">point</see> of the dimension.</param>
 /// <param name="secondPoint">Second reference <see cref="Vector2">point</see> of the dimension.</param>
 /// <param name="offset">Distance between the reference line and the dimension line.</param>
 /// <param name="style">The <see cref="DimensionStyle">style</see> to use with the dimension.</param>
 /// <remarks>The reference points define the distance to be measure.</remarks>
 public AlignedDimension(Vector2 firstPoint, Vector2 secondPoint, double offset, DimensionStyle style)
     : this(new Vector3(firstPoint.X, firstPoint.Y, 0.0), new Vector3(secondPoint.X, secondPoint.Y, 0.0), offset, style)
 {
 }
コード例 #18
0
 /// <summary>
 /// Initializes a new instance of the <c>AlignedDimension</c> class.
 /// </summary>
 /// <param name="firstPoint">First reference <see cref="Vector2">point</see> of the dimension.</param>
 /// <param name="secondPoint">Second reference <see cref="Vector2">point</see> of the dimension.</param>
 /// <param name="offset">Distance between the reference line and the dimension line.</param>
 /// <param name="style">The <see cref="DimensionStyle">style</see> to use with the dimension.</param>
 /// <remarks>The reference points define the distance to be measure.</remarks>
 public AlignedDimension(Vector2 firstPoint, Vector2 secondPoint, double offset, DimensionStyle style)
     : base(DimensionType.Aligned)
 {
     this.firstRefPoint  = firstPoint;
     this.secondRefPoint = secondPoint;
     if (offset < 0)
     {
         throw new ArgumentOutOfRangeException(nameof(offset), "The offset value must be equal or greater than zero.");
     }
     this.offset = offset;
     if (style == null)
     {
         throw new ArgumentNullException(nameof(style));
     }
     this.Style = style;
     this.Update();
 }
コード例 #19
0
 /// <summary>
 /// Initializes a new instance of the <c>AlignedDimension</c> class.
 /// </summary>
 /// <param name="referenceLine">Reference <see cref="Line">line</see> of the dimension.</param>
 /// <param name="offset">Distance between the reference line and the dimension line.</param>
 /// <param name="style">The <see cref="DimensionStyle">style</see> to use with the dimension.</param>
 /// <remarks>The reference line define the distance to be measure.</remarks>
 public AlignedDimension(Line referenceLine, double offset, DimensionStyle style)
     : this(referenceLine.StartPoint, referenceLine.EndPoint, offset, style)
 {
     this.normal = referenceLine.Normal;
 }
コード例 #20
0
 /// <summary>
 /// Initializes a new instance of the <c>AlignedDimension</c> class.
 /// </summary>
 /// <param name="referenceLine">Reference <see cref="Line">line</see> of the dimension.</param>
 /// <param name="offset">Distance between the reference line and the dimension line.</param>
 /// <param name="style">The <see cref="DimensionStyle">style</see> to use with the dimension.</param>
 /// <remarks>The reference points define the distance to be measure.</remarks>
 public AlignedDimension(Line referenceLine, double offset, DimensionStyle style)
     : this(referenceLine, offset, Vector3.UnitZ, style)
 {
 }
コード例 #21
0
        /// <summary>
        /// Initializes a new instance of the <c>OrdinateDimension</c> class.
        /// </summary>
        /// <param name="origin">Origin <see cref="Vector3">point</see> in world coordinates of the ordinate dimension.</param>
        /// <param name="featurePoint">Base location <see cref="Vector2">point</see> in local coordinates of the ordinate dimension.</param>
        /// <param name="length">Length of the dimension line.</param>
        /// <param name="axis">Local axis that measures the ordinate dimension.</param>
        /// <param name="rotation">Angle of rotation in degrees of the dimension lines.</param>
        /// <param name="style">The <see cref="DimensionStyle">style</see> to use with the dimension.</param>
        /// <remarks>The local coordinate system of the dimension is defined by the dimension normal and the rotation value.</remarks>
        public OrdinateDimension(Vector2 origin, Vector2 featurePoint, double length, OrdinateDimensionAxis axis, double rotation, DimensionStyle style)
            : base(DimensionType.Ordinate)
        {
            this.defPoint   = origin;
            this.rotation   = MathHelper.NormalizeAngle(rotation);
            this.firstPoint = featurePoint;
            this.axis       = axis;

            if (style == null)
            {
                throw new ArgumentNullException(nameof(style));
            }
            this.Style = style;

            double angle = rotation * MathHelper.DegToRad;

            if (this.Axis == OrdinateDimensionAxis.X)
            {
                angle += MathHelper.HalfPI;
            }
            this.secondPoint  = Vector2.Polar(featurePoint, length, angle);
            this.textRefPoint = this.secondPoint;
        }
コード例 #22
0
        private void ReAsignHandlersAndDefaultObjects()
        {
            this.handleCount = 100;

            //add default viewports
            ViewPort active = ViewPort.Active;

            if (!this.viewports.ContainsKey(active.Name))
            {
                this.viewports.Add(active.Name, active);
            }
            foreach (ViewPort viewPort in this.viewports.Values)
            {
                this.handleCount = viewPort.AsignHandle(this.handleCount);
            }

            //add default layer
            Layer.PlotStyleHandle = Convert.ToString(this.handleCount++, 16);
            Layer byDefault = Layer.Default;

            if (!this.layers.ContainsKey(byDefault.Name))
            {
                this.layers.Add(byDefault.Name, byDefault);
            }
            foreach (Layer layer in this.layers.Values)
            {
                this.handleCount = layer.AsignHandle(this.handleCount);
            }

            // add default line types
            LineType byLayer = LineType.ByLayer;
            LineType byBlock = LineType.ByBlock;

            if (!this.lineTypes.ContainsKey(byLayer.Name))
            {
                this.lineTypes.Add(byLayer.Name, byLayer);
            }
            if (!this.lineTypes.ContainsKey(byBlock.Name))
            {
                this.lineTypes.Add(byBlock.Name, byBlock);
            }
            foreach (LineType lineType in this.lineTypes.Values)
            {
                this.handleCount = lineType.AsignHandle(this.handleCount);
            }

            // add default text style
            TextStyle defaultStyle = TextStyle.Default;

            if (!this.textStyles.ContainsKey(defaultStyle.Name))
            {
                this.textStyles.Add(defaultStyle.Name, defaultStyle);
            }
            foreach (TextStyle textStyle in this.textStyles.Values)
            {
                this.handleCount = textStyle.AsignHandle(this.handleCount);
            }

            // add default blocks
            Block modelSpace = Block.ModelSpace;
            Block paperSpace = Block.PaperSpace;

            if (!this.blocks.ContainsKey(modelSpace.Name))
            {
                this.blocks.Add(modelSpace.Name, modelSpace);
            }
            if (!this.blocks.ContainsKey(paperSpace.Name))
            {
                this.blocks.Add(paperSpace.Name, paperSpace);
            }
            foreach (Block block in this.blocks.Values)
            {
                this.handleCount = block.AsignHandle(this.handleCount);
            }

            // add default application registry
            ApplicationRegistry defaultAppId = ApplicationRegistry.Default;

            if (!this.appRegisterNames.ContainsKey(defaultAppId.Name))
            {
                this.appRegisterNames.Add(defaultAppId.Name, defaultAppId);
            }
            foreach (ApplicationRegistry appId in this.appRegisterNames.Values)
            {
                this.handleCount = appId.AsignHandle(this.handleCount);
            }

            //add default dimension style
            DimensionStyle defaultDimStyle = DimensionStyle.Default;

            if (!this.dimStyles.ContainsKey(defaultDimStyle.Name))
            {
                this.dimStyles.Add(defaultDimStyle.Name, defaultDimStyle);
            }
            foreach (DimensionStyle style in this.dimStyles.Values)
            {
                this.handleCount = style.AsignHandle(this.handleCount);
            }

            foreach (Arc entity in this.arcs)
            {
                this.handleCount = entity.AsignHandle(this.handleCount);
            }
            foreach (Ellipse entity in this.ellipses)
            {
                this.handleCount = entity.AsignHandle(this.handleCount);
            }
            foreach (Face3d entity in this.faces3d)
            {
                this.handleCount = entity.AsignHandle(this.handleCount);
            }
            foreach (Solid entity in this.solids)
            {
                this.handleCount = entity.AsignHandle(this.handleCount);
            }
            foreach (Insert entity in this.inserts)
            {
                this.handleCount = entity.AsignHandle(this.handleCount);
            }
            foreach (IPolyline entity in this.polylines)
            {
                this.handleCount = ((DxfObject)entity).AsignHandle(this.handleCount);
            }
            foreach (Line entity in this.lines)
            {
                this.handleCount = entity.AsignHandle(this.handleCount);
            }
            foreach (Circle entity in this.circles)
            {
                this.handleCount = entity.AsignHandle(this.handleCount);
            }
            foreach (Point entity in this.points)
            {
                this.handleCount = entity.AsignHandle(this.handleCount);
            }
            foreach (Text entity in this.texts)
            {
                this.handleCount = entity.AsignHandle(this.handleCount);
            }
        }
コード例 #23
0
 /// <summary>
 /// Initializes a new instance of the <c>Angular3PointDimension</c> class.
 /// </summary>
 /// <param name="centerPoint">Center of the angle arc to measure.</param>
 /// <param name="startPoint">Angle start point.</param>
 /// <param name="endPoint">Angle end point.</param>
 /// <param name="offset">Distance between the center point and the dimension line.</param>
 /// <param name="style">The <see cref="DimensionStyle">style</see> to use with the dimension.</param>
 public Angular3PointDimension(Vector2 centerPoint, Vector2 startPoint, Vector2 endPoint, double offset, DimensionStyle style)
     : base(DimensionType.Angular3Point)
 {
     this.center = centerPoint;
     this.start  = startPoint;
     this.end    = endPoint;
     if (offset < 0)
     {
         throw new ArgumentOutOfRangeException(nameof(offset), "The offset value must be equal or greater than zero.");
     }
     this.offset = offset;
     if (style == null)
     {
         throw new ArgumentNullException(nameof(style));
     }
     this.Style = style;
     this.Update();
 }
コード例 #24
0
ファイル: Leader.cs プロジェクト: wieslawsoltes/netDxf
 /// <summary>
 /// Initializes a new instance of the <c>Leader</c> class.
 /// </summary>
 /// <param name="text">Leader text annotation.</param>
 /// <param name="vertexes">List of leader vertexes in local coordinates.</param>
 /// <param name="style">Leader style.</param>
 public Leader(string text, IEnumerable <Vector2> vertexes, DimensionStyle style)
     : this(vertexes, style)
 {
     this.Annotation = this.BuildAnnotation(text);
 }
コード例 #25
0
 /// <summary>
 /// Initializes a new instance of the <c>Angular2LineDimension</c> class.
 /// </summary>
 /// <param name="firstLine">First <see cref="Line">line</see> that defines the angle to measure.</param>
 /// <param name="secondLine">Second <see cref="Line">line</see> that defines the angle to measure.</param>
 /// <param name="offset">Distance between the center point and the dimension line.</param>
 /// <param name="style">The <see cref="DimensionStyle">style</see> to use with the dimension.</param>
 public Angular2LineDimension(Line firstLine, Line secondLine, double offset, DimensionStyle style)
     : this(firstLine, secondLine, offset, Vector3.UnitZ, style)
 {
 }
コード例 #26
0
ファイル: Leader.cs プロジェクト: wieslawsoltes/netDxf
 /// <summary>
 /// Initializes a new instance of the <c>Leader</c> class.
 /// </summary>
 /// <param name="tolerance">Leader tolerance annotation.</param>
 /// <param name="vertexes">List of leader vertexes in local coordinates.</param>
 /// <param name="style">Leader style.</param>
 public Leader(ToleranceEntry tolerance, IEnumerable <Vector2> vertexes, DimensionStyle style)
     : this(vertexes, style)
 {
     this.Annotation = this.BuildAnnotation(tolerance);
 }
コード例 #27
0
        /// <summary>
        /// Draws the panel.
        /// </summary>
        /// <param name="xLowerBound">The x lower bound.</param>
        /// <param name="xUpperBound">The x upper bound.</param>
        /// <param name="yLowerBound">The y lower bound.</param>
        /// <param name="yUpperBound">The y upper bound.</param>
        /// <param name="panel">The panel.</param>
        /// <param name="para">The para.</param>
        public static void drawPanel(double xLowerBound, double xUpperBound, double yLowerBound, double yUpperBound, PerforationPanel panel, bool fixingHolesManipulated, bool enablePerf)
        {
            RhinoDoc    doc        = RhinoDoc.ActiveDoc;
            List <Guid> guidList   = new List <Guid>();
            string      layerName  = null;                       //name of layers
            int         layerIndex = 0;                          //index of layers

            Rhino.DocObjects.Layer parent_layer_Approval = null; //create variable to hold approval layer
            Rhino.DocObjects.Layer parent_layer_Nesting  = null; //create variable to hold nesting layer
                                                                 //Rhino.DocObjects.Layer childlayer = null; //Create a variable to hold child layers
            string       text   = "";
            double       height = panel.labelHeight / 3;
            const string font   = "Arial";
            Guid         burrLeader;
            RhinoObject  labelText;

            Rhino.Geometry.Point3d pt    = new Rhino.Geometry.Point3d(0, 0, 0);
            Rhino.Geometry.Plane   plane = doc.Views.ActiveView.ActiveViewport.ConstructionPlane();

            //start
            //Creating layer called "Layers for Approval Drawings" to make it a parent layer
            layerName = "LAYERS FOR APPROVAL DRAWINGS";
            // Does a layer with the same name already exist?
            layerIndex = doc.Layers.Find(layerName, true);

            // If layer does not exist
            if (layerIndex == -1)
            {
                // Add a new layer to the document
                layerIndex            = doc.Layers.Add(layerName, System.Drawing.Color.Black);
                parent_layer_Approval = doc.Layers[layerIndex]; //set the layer as parent layer
            }
            else
            {
                parent_layer_Approval = doc.Layers[layerIndex];
            }

            layerName = "LAYERS FOR NESTING";

            // Does a layer with the same name already exist?
            layerIndex = doc.Layers.Find(layerName, true);

            // If layer does not exist
            if (layerIndex == -1)
            {
                // Add a new layer to the document
                layerIndex           = doc.Layers.Add(layerName, System.Drawing.Color.Black);
                parent_layer_Nesting = doc.Layers[layerIndex];
            }
            else
            {
                parent_layer_Nesting = doc.Layers[layerIndex];
            }


            // Create a new layer called Perimeter
            layerName = "PANEL PERIMETER";

            layerIndex = createSubLayers.createSubLayer(layerName,
                                                        System.Drawing.Color.Black, parent_layer_Nesting); //make Nesting layer the parent layer

            doc.Layers.SetCurrentLayerIndex(layerIndex, true);

            //Bottom and left justified the panels in the grid (panel x0,x1,y0,y1 - refers to the folds edg (folds layer)
            double panelX0 = xLowerBound;
            double panelX1 = panelX0 + panel.X;
            double panelY0 = yUpperBound;
            double panelY1 = panelY0 + panel.Y;

            List <Point3d> list = new List <Point3d>();

            panel.Perimeter = doc.Objects.AddLine(new Point3d(panelX0, panelY1, 0), new Point3d(panelX1, panelY1, 0));
            guidList.Add(panel.Perimeter);

            panel.Perimeter = doc.Objects.AddLine(new Point3d(panelX0, panelY0, 0), new Point3d(panelX0, panelY1, 0));
            guidList.Add(panel.Perimeter);

            panel.Perimeter = doc.Objects.AddLine(new Point3d(panelX0, panelY0, 0), new Point3d(panelX1, panelY0, 0));
            guidList.Add(panel.Perimeter);

            panel.Perimeter = doc.Objects.AddLine(new Point3d(panelX1, panelY0, 0), new Point3d(panelX1, panelY1, 0));
            guidList.Add(panel.Perimeter);

            //MetrixUtilities.joinCurves(doc.Layers.Find("PANEL PERIMETER", true)); //join the closed curves using the method


            //Calculating the borders
            double borderX0 = panelX0 + panel.LeftBorder;  //refers to the borders corners
            double borderY0 = panelY0 + panel.BottomBorder;
            double borderX1 = panelX1 - panel.RightBorder;
            double borderY1 = panelY1 - panel.TopBorder;

            BoundingBox    panelBox          = new BoundingBox(borderX0, borderY0, 0, borderX1, borderY1, 0);
            List <Point3d> rectangle_corners = panelBox.GetCorners().Distinct().ToList();

            // add 1st point at last to close the loop
            rectangle_corners.Add(rectangle_corners[0]);
            // Create a new layer called Border

            layerName  = "BORDERS";
            layerIndex = createSubLayers.createSubLayer(layerName,
                                                        System.Drawing.Color.Purple, parent_layer_Approval); //pass to the method, make Approval layer the parent layer

            doc.Layers.SetCurrentLayerIndex(layerIndex, true);
            //Add the borders only if the panel is not solid
            if (panel.DrawPerf != 3)
            {
                //Create a bounding box for the borders
                panel.Border = doc.Objects.AddPolyline(rectangle_corners);
                guidList.Add(panel.Border);
            }

            // Create a new layer called LABELS
            layerName  = "LABELS";
            layerIndex = createSubLayers.createSubLayer(layerName,
                                                        System.Drawing.Color.Red, parent_layer_Nesting); //pass to the method, make Nesting layer the parent layer

            doc.Layers.SetCurrentLayerIndex(layerIndex, true);
            text         = panel.PartName;
            height       = panel.labelHeight;
            pt           = new Rhino.Geometry.Point3d(borderX0, borderY0 + 4 + height, 0);
            plane        = doc.Views.ActiveView.ActiveViewport.ConstructionPlane();
            plane.Origin = pt;
            panel.Label  = doc.Objects.AddText(text, plane, height, font, false, false);
            guidList.Add(panel.Label);

            RhinoApp.RunScript("SelNone", true);
            labelText = doc.Objects.Find(panel.Label);
            labelText.Select(true);
            BoundingBox bbox = labelText.Geometry.GetBoundingBox(true);
            double      minX = bbox.Corner(true, true, true).X;
            double      maxX = bbox.Corner(false, true, true).X;
            double      minY = bbox.Corner(true, true, true).Y;
            double      maxY = bbox.Corner(true, false, true).Y;

            if (maxX - minX >= panel.X - panel.LeftBorder - panel.RightBorder)
            {
                double ratio = 1;
                labelText.Select(true);
                if (panel.Y > panel.X)
                {
                    RhinoApp.RunScript("_-rotate " + bbox.Center.X + "," + bbox.Center.Y + " " + "90", true);
                }

                if (maxY - minY + 4 >= panel.X - panel.LeftBorder - panel.RightBorder)
                {
                    ratio = (panel.X - panel.LeftBorder - panel.RightBorder) / (2 * (maxY - minY));
                    if (ratio * (maxX - minX) >= (panel.Y - panel.TopBorder - panel.BottomBorder))
                    {
                        ratio = ratio * (panel.Y - panel.TopBorder - panel.BottomBorder) / (2 * ratio * (maxX - minX));
                    }
                }
                else if (maxX - minX >= panel.Y - panel.TopBorder - panel.BottomBorder)
                {
                    ratio = (panel.Y - panel.TopBorder - panel.BottomBorder) / (2 * (maxX - minX));
                }
                RhinoApp.RunScript("_-Scale " + bbox.Center.X + "," + bbox.Center.Y + " " + ratio, true);
                BoundingBox bbox3     = labelText.Geometry.GetBoundingBox(true);
                double      distance1 = borderX0 + ratio * (bbox3.Max.X - bbox3.Min.X) / 2;
                double      distance2 = borderY0 + ratio * (bbox3.Max.Y - bbox3.Min.Y) / 2;
                if (panel.Y > panel.X)
                {
                    distance1 = borderX0 + ratio * (bbox3.Max.Y - bbox3.Min.Y) / 2;
                    distance2 = borderY0 + ratio * (bbox3.Max.X - bbox3.Min.X) / 2;
                }

                RhinoApp.WriteLine(bbox3.Center.ToString());
                RhinoApp.RunScript("_-Move " + bbox3.Center.X + "," + bbox3.Center.Y + ",0 " + distance1 + "," + distance2 + ",0", true);
            }
            else if (maxY - minY >= panel.Y - panel.TopBorder - panel.BottomBorder)
            {
                double ratio = (panel.Y - panel.TopBorder - panel.BottomBorder) / (2 * (maxY - minY));
                labelText.Select(true);
                RhinoApp.RunScript("_-Scale " + bbox.Center.X + "," + bbox.Center.Y + " " + ratio, true);
                BoundingBox bbox2     = labelText.Geometry.GetBoundingBox(true);
                double      distanceX = borderX0 + ratio * (bbox2.Center.X - bbox2.Min.X) / 2;
                double      distanceY = panelBox.Min.Y + ratio * (bbox2.Center.Y - bbox.Min.Y) / 2;

                RhinoApp.WriteLine(bbox2.Center.ToString());
                RhinoApp.RunScript("_-Move " + bbox2.Center.X + "," + bbox2.Center.Y + ",0 " + distanceX + "," + distanceY + ",0", true);
            }
            labelText.Select(false);

            // If dotFontLabel is more than 0 draw the dot font text on the panel, else skip
            // if (para.DotFont == 1)
            if (panel.DotFontLabel > 0)
            {
                // Create a new layer called DOT SCRIBE LABEL
                layerName = "DOT SCRIBE LABEL";

                layerIndex = createSubLayers.createSubLayer(layerName,
                                                            System.Drawing.Color.Black, parent_layer_Nesting); //make Nesting layer the parent layer


                doc.Layers.SetCurrentLayerIndex(layerIndex, true);

                // Put in the Dot Matrix Label
                // Draw at the right side of the border aand 10mm from the bottom and 100mm from the left edge
                double panelOffset = 0;
                if (panel.BottomBorder - 8.7 <= 6)
                {
                    panelOffset = (panel.BottomBorder - 8.7) / 2;
                }
                else
                {
                    panelOffset = 3.1;
                }
                if (panel.X < 160)
                {
                    pt = new Point3d(1 * (panelX0 + panelX1) / 2, panelY0 + panelOffset + 8.7, 0);
                }
                else
                {
                    pt = new Point3d(panelX1 - 100, panelY0 + panelOffset + 8.7, 0);
                }
                if (panel.DotFontLabellerSide.Equals("Rear"))
                {
                    DotMatrixLabellerCommand.Instance.drawDotMatrix(pt, panel.PartName, 8.7, panel.X); //set the size of dotfont
                }
                else //If not revered use front labeller
                {
                    DotMatrixFrontLabellerCommand.Instance.drawDotMatrix(pt, panel.PartName, 8.7);
                }
            }
            //checks whether the perforation layers exists, if not create layer and make Approval layer the parent layer
            //If exists, make Approval layer the parent layer
            layerName  = "PERFORATION";
            layerIndex = createSubLayers.createSubLayer(layerName,
                                                        System.Drawing.Color.Green, parent_layer_Approval);

            // doc.Layers.SetCurrentLayerIndex(layerIndex, true);

            //Create Temporary Layer

            if (panel.DrawPerf == 1)
            {
                RhinoUtilities.SetActiveLayer("TemporaryPerfLayer", System.Drawing.Color.Green);
                doc.Views.Redraw();

                RhinoApp.RunScript("SelAll", true);
                RhinoApp.RunScript("-_Rotate 0,0,0 -" + panel.patternDirection, true);
                PerforationForm perforationForm = new PerforationForm(new Rhino.DocObjects.ObjRef(panel.Border).Curve());
                perforationForm.enablePerforation = enablePerf;
                perforationForm.drawPerforationDesign(panel.PatternName, true, enablePerf);
                RhinoApp.RunScript("SelAll", true);
                RhinoApp.RunScript("-_Rotate 0,0,0 " + panel.patternDirection, true);
                RhinoApp.RunScript("SelNone", true);

                var rhinoObjects        = doc.Objects.FindByLayer("TemporaryPerfLayer");
                var toolHitObjects      = doc.Objects.FindByLayer("TemporaryToolHit");
                var temporaryTool2Layer = doc.Objects.FindByLayer("TemporaryTool2Layer");

                //Perf objects
                if (rhinoObjects != null && rhinoObjects.Length > 1)
                {
                    foreach (var rhinObj in rhinoObjects)
                    {
                        rhinObj.Select(true);
                    }
                    if (panel.patternDirection == 1)
                    {
                        RhinoApp.RunScript("-_Rotate 0,0,0 -90", true);
                        RhinoApp.RunScript("-_Rotate 0,0,0 90", true);
                    }

                    RhinoUtilities.SetActiveLayer(Properties.Settings.Default.PerforationLayerName, System.Drawing.Color.Green);
                    RhinoApp.RunScript("-_ChangeLayer PERFORATION", true);
                    int index = doc.Layers.Find("TemporaryPerfLayer", true);
                    doc.Layers.Delete(index, true);
                }

                //tool hit objects
                if (toolHitObjects != null && toolHitObjects.Length > 1)
                {
                    foreach (var toolhitObj in toolHitObjects)
                    {
                        toolhitObj.Select(true);
                    }

                    if (panel.patternDirection == 1)
                    {
                        RhinoApp.RunScript("-_Rotate 0,0,0 -90", true);
                        RhinoApp.RunScript("-_Rotate 0,0,0 90", true);
                    }
                    RhinoUtilities.SetActiveLayer(Properties.Settings.Default.ToolHitLayerName, System.Drawing.Color.Black);
                    RhinoApp.RunScript("-_ChangeLayer TOOL HIT", true);
                    int index = doc.Layers.Find("TemporaryToolHit", true);
                    doc.Layers.Delete(index, true);
                }

                //Tool 2 objects
                if (temporaryTool2Layer != null && temporaryTool2Layer.Length > 1)
                {
                    foreach (var tool2Objs in temporaryTool2Layer)
                    {
                        tool2Objs.Select(true);
                    }
                    if (panel.patternDirection == 1)
                    {
                        RhinoApp.RunScript("-_Rotate 0,0,0 -90", true);
                        RhinoApp.RunScript("-_Rotate 0,0,0 90", true);
                    }

                    RhinoUtilities.SetActiveLayer("Tool 2 Layer", System.Drawing.Color.Yellow);
                    RhinoApp.RunScript("-_ChangeLayer Tool 2 Layer", true);
                    int index = doc.Layers.Find("TemporaryTool2Layer", true);
                    doc.Layers.Delete(index, true);
                }
                doc.Views.Redraw();
            }


            DimensionStyle dimStyle = MetrixUtilities.createMetrixRealDimension(); //sets the metrix real dimension

            Point3d         origin = new Point3d(0, 0, 0);
            Point3d         offset = new Point3d(0, 0, 0);
            Point2d         ext1;
            Point2d         ext2;
            Point2d         linePt;
            LinearDimension dimension;
            Guid            dimGuid = new Guid();
            double          u, v;


            // Create a new layer called DIMENSIONS BLACK
            layerName  = "DIMENSIONS BLACK";
            layerIndex = createSubLayers.createSubLayer(layerName,
                                                        System.Drawing.Color.Black, parent_layer_Approval); //pass to the method, make Approval layer the parent layer

            doc.Layers.SetCurrentLayerIndex(layerIndex, true);

            // Add the word perforated area to the panel
            if (panel.DrawPerf != 3) //Add the text only if the panel is not a solid panel
            {
                //pt = new Rhino.Geometry.Point3d(((borderX1 + borderX0) / 2) - 117.5, ((borderY1 + borderY0) / 2) + 33, 0);
                text         = System.Text.RegularExpressions.Regex.Unescape(panel.PerfText);
                height       = panel.labelHeight / 2;
                pt           = new Rhino.Geometry.Point3d(((borderX1 + borderX0) / 2) - 117.5, ((borderY1 + borderY0) / 2) + 10 + height, 0);
                plane.Origin = pt;
                Guid perforatedAreaLabel = doc.Objects.AddText(text, plane, height, font, false, false);
                guidList.Add(perforatedAreaLabel);

                double ratio = 1;

                if (panel.X - panel.LeftBorder - panel.RightBorder < 230)
                {
                    RhinoApp.RunScript("SelNone", true);
                    labelText = doc.Objects.Find(perforatedAreaLabel);
                    labelText.Select(true);
                    bbox = labelText.Geometry.GetBoundingBox(true);
                    if (panel.Y > panel.X)
                    {
                        RhinoApp.RunScript("_-rotate " + bbox.Center.X + "," + bbox.Center.Y + " " + "90", true);
                    }

                    minX = bbox.Corner(true, true, true).X;
                    maxX = bbox.Corner(false, true, true).X;
                    minY = bbox.Corner(true, true, true).Y;
                    maxY = bbox.Corner(true, false, true).Y;

                    if (maxY - minY > panel.X - panel.LeftBorder - panel.RightBorder)
                    {
                        ratio = (panel.X - panel.LeftBorder - panel.RightBorder) / (2 * (maxY - minY));
                        if (ratio * (maxX - minX) > (panel.Y - panel.TopBorder - panel.BottomBorder))
                        {
                            ratio = ratio * (panel.Y - panel.TopBorder - panel.BottomBorder) / (2 * ratio * (maxX - minX));
                        }
                    }
                    else if (maxX - minX >= panel.Y - panel.TopBorder - panel.BottomBorder)
                    {
                        ratio = (panel.Y - panel.TopBorder - panel.BottomBorder) / (2 * (maxX - minX));
                    }
                    labelText.Select(true);
                    RhinoApp.RunScript("_-Scale " + bbox.Center.X + "," + bbox.Center.Y + " " + ratio, true);
                    BoundingBox bbox2     = labelText.Geometry.GetBoundingBox(true);
                    double      distanceX = (borderX0 + borderX1) / 2;
                    double      distanceY = (borderY0 + borderY1) / 2;

                    RhinoApp.WriteLine(bbox2.Center.ToString());
                    RhinoApp.RunScript("_-Move " + bbox2.Center.X + "," + bbox2.Center.Y + ",0 " + distanceX + "," + distanceY + ",0", true);
                }
                else
                {
                    RhinoApp.RunScript("SelNone", true);
                    labelText = doc.Objects.Find(perforatedAreaLabel);
                    labelText.Select(true);
                    bbox = labelText.Geometry.GetBoundingBox(true);
                    minX = bbox.Corner(true, true, true).X;
                    maxX = bbox.Corner(false, true, true).X;
                    minY = bbox.Corner(true, true, true).Y;
                    maxY = bbox.Corner(true, false, true).Y;

                    if (maxX - minX > panel.Y - panel.TopBorder - panel.BottomBorder)
                    {
                        ratio = (panel.Y - panel.TopBorder - panel.BottomBorder) / (2 * (maxY - minY));
                        labelText.Select(true);
                        RhinoApp.RunScript("_-Scale " + bbox.Center.X + "," + bbox.Center.Y + " " + ratio, true);
                    }
                    BoundingBox bbox2     = labelText.Geometry.GetBoundingBox(true);
                    double      distanceX = (borderX0 + borderX1) / 2;
                    double      distanceY = (borderY0 + borderY1) / 2;

                    RhinoApp.WriteLine(bbox2.Center.ToString());
                    RhinoApp.RunScript("_-Move " + bbox2.Center.X + "," + bbox2.Center.Y + ",0 " + distanceX + "," + distanceY + ",0", true);
                }
            }

            // Add horizontal dimension
            origin = new Point3d(panelX1, panelY0 - 50, 0);
            offset = new Point3d(panelX0, panelY0 - 50, 0);
            pt     = new Point3d((offset.X - origin.X) / 2, panelY0 - 100, 0);

            plane        = Plane.WorldXY;
            plane.Origin = origin;

            //double u, v;
            plane.ClosestParameter(origin, out u, out v);
            ext1 = new Point2d(u, v);

            plane.ClosestParameter(offset, out u, out v);
            ext2 = new Point2d(u, v);

            plane.ClosestParameter(pt, out u, out v);
            linePt = new Point2d(u, v);


            dimension = new LinearDimension(plane, ext1, ext2, linePt);
            dimGuid   = doc.Objects.AddLinearDimension(dimension);       //add the bottom dimension(vertical line)
            guidList.Add(dimGuid);

            // Add vertical dimension for panel

            origin = new Point3d(panelX0 - 20, panelY0, 0);
            offset = new Point3d(panelX0 - 20, panelY1, 0);
            pt     = new Point3d(panelX0 - 100, (offset.Y - origin.Y) / 2, 0);

            plane        = Plane.WorldXY;
            plane.XAxis  = new Vector3d(0, -1, 0);
            plane.YAxis  = new Vector3d(-1, 0, 0);
            plane.ZAxis  = new Vector3d(0, 0, -1);
            plane.Origin = origin;

            plane.ClosestParameter(origin, out u, out v);
            ext1 = new Point2d(u, v);

            plane.ClosestParameter(offset, out u, out v);
            ext2 = new Point2d(u, v);

            plane.ClosestParameter(pt, out u, out v);
            linePt = new Point2d(u, v);

            dimension = new LinearDimension(plane, ext1, ext2, linePt);
            dimGuid   = doc.Objects.AddLinearDimension(dimension); //adds the left dimension

            guidList.Add(dimGuid);


            MetrixUtilities.createMetrixBordersDimension(); //sets the dimension style for borders

            // Draw Border dimension on BORDERS layer
            if (panel.DrawPerf != 3) ///Add only if the panel is not a solid panel
            {
                layerName  = "BORDERS";
                layerIndex = doc.Layers.Find(layerName, true);
                doc.Layers.SetCurrentLayerIndex(layerIndex, true);

                // Add horizontal borders dimension
                origin = new Point3d(panelX1, (panelY0 + panelY1) / 2, 0);
                offset = new Point3d(borderX1, (panelY0 + panelY1) / 2, 0);
                pt     = new Point3d((offset.X - origin.X) / 2, (borderY0 + borderY1) / 2, 0);

                plane        = Plane.WorldXY;
                plane.Origin = origin;

                plane.ClosestParameter(origin, out u, out v);
                ext1 = new Point2d(u, v);

                plane.ClosestParameter(offset, out u, out v);
                ext2 = new Point2d(u, v);

                plane.ClosestParameter(pt, out u, out v);
                linePt = new Point2d(u, v);

                dimension = new LinearDimension(plane, ext1, ext2, linePt);
                dimGuid   = doc.Objects.AddLinearDimension(dimension);

                guidList.Add(dimGuid);

                // Add horizontal borders dimension
                origin = new Point3d(panelX0, (panelY0 + panelY1) / 2, 0);
                offset = new Point3d(borderX0, (panelY0 + panelY1) / 2, 0);
                pt     = new Point3d((offset.X - origin.X) / 2, (borderY0 + borderY1) / 2, 0);


                plane.ClosestParameter(origin, out u, out v);
                ext1 = new Point2d(u, v);

                plane.ClosestParameter(offset, out u, out v);
                ext2 = new Point2d(u, v);

                plane.ClosestParameter(pt, out u, out v);
                linePt = new Point2d(u, v);

                dimension = new LinearDimension(plane, ext1, ext2, linePt);
                dimGuid   = doc.Objects.AddLinearDimension(dimension);

                guidList.Add(dimGuid);

                // Add vertical border dimension for panel

                origin = new Point3d((panelX0 + panelX1) / 2, panelY0, 0);
                offset = new Point3d((panelX0 + panelX1) / 2, borderY0, 0);
                pt     = new Point3d((borderX0 + borderX1) / 2, (offset.Y - origin.Y) / 2, 0);

                plane        = Plane.WorldXY;
                plane.XAxis  = new Vector3d(0, -1, 0);
                plane.YAxis  = new Vector3d(-1, 0, 0);
                plane.ZAxis  = new Vector3d(0, 0, -1);
                plane.Origin = origin;

                plane.ClosestParameter(origin, out u, out v);
                ext1 = new Point2d(u, v);

                plane.ClosestParameter(offset, out u, out v);
                ext2 = new Point2d(u, v);

                plane.ClosestParameter(pt, out u, out v);
                linePt = new Point2d(u, v);

                dimension = new LinearDimension(plane, ext1, ext2, linePt);
                dimGuid   = doc.Objects.AddLinearDimension(dimension);

                guidList.Add(dimGuid);

                origin = new Point3d((panelX0 + panelX1) / 2, panelY1, 0);
                offset = new Point3d((panelX0 + panelX1) / 2, borderY1, 0);
                pt     = new Point3d((borderX0 + borderX1) / 2, (offset.Y - origin.Y) / 2, 0);

                plane.ClosestParameter(origin, out u, out v);
                ext1 = new Point2d(u, v);

                plane.ClosestParameter(offset, out u, out v);
                ext2 = new Point2d(u, v);

                plane.ClosestParameter(pt, out u, out v);
                linePt = new Point2d(u, v);

                dimension = new LinearDimension(plane, ext1, ext2, linePt);
                dimGuid   = doc.Objects.AddLinearDimension(dimension);

                guidList.Add(dimGuid);
            }

            MetrixUtilities.createMetrixRealDimension(); //sets the default dimension style
            layerName  = "VIEWPORT";
            layerIndex = createSubLayers.createSubLayer(layerName,
                                                        System.Drawing.Color.Black, parent_layer_Approval); //pass to the method, make Approval layer the parent layer

            doc.Layers.SetCurrentLayerIndex(layerIndex, true);



            Rhino.DocObjects.RhinoObject label = doc.Objects.Find(panel.Label);
            string exportFileName = "1";

            if (label != null)
            {
                label.Select(true);
                Rhino.Geometry.TextEntity textentity = label.Geometry as Rhino.Geometry.TextEntity;
                exportFileName = textentity.Text + ".dxf";
            }


            /**
             * Checks if the dxf files are required by the user, if yes check whether the panel is perforated
             * using the drawPerf property in the panel. If it is a perforated panel then check if the directory
             * for perforated panels dxf files already exists, if does not exist create directory and run command.
             * If panel is not perforated, create directory to save not perforated panels dxf files if the directory
             * does not exist. Then run the dxf file create command.
             * */
            if (panel.DXFFilesRequired.Equals("Yes"))
            {
                String path;
                String immediateFolderName = Path.GetFileName(Path.GetDirectoryName(doc.Path)); //get the immediate foldername which the file is located in
                                                                                                //split the path to get the parent folder.
                String[] newPath = MetrixUtilities.splitString(Path.GetDirectoryName(doc.Path), immediateFolderName);
                if (panel.DrawPerf == 1)                                                        //checks if panel is perforated
                {
                    path = newPath[0] + ("5TRUMPF") + ("\\WITH PERF");                          //merge path for perforated files
                    if (!Directory.Exists(path))                                                //check if directory already exists
                    {
                        System.IO.Directory.CreateDirectory(path);                              //create directory if not exist
                    }
                }
                else
                {
                    path = newPath[0] + ("5TRUMPF") + ("\\NO PERF"); //merge path for not perforated files
                    if (!Directory.Exists(path))                     //check if directory already exists
                    {
                        System.IO.Directory.CreateDirectory(path);   //create directory if not exist
                    }
                }
                string command = string.Format("-_Export \"" + path + @"\" + exportFileName + "\"  Scheme \"R12 Lines & Arcs\" Enter");
                // Export the selected curves
                RhinoApp.RunScript(command, true);
            }
            // Unselect all objects
            doc.Objects.UnselectAll();

            // Default layer index
            int defaultLayerIndex = doc.Layers.Find("Default", true);

            doc.Layers.SetCurrentLayerIndex(layerIndex, true);

            ////if draw perf is false, turnoff the toolhit layer
            //if (Convert.ToBoolean(panel.DrawPerf) != true)
            //{
            //   layerName = "Tool Hit";
            //   layerIndex = doc.Layers.Find(layerName, true);
            //   doc.Layers[layerIndex].IsVisible = false;
            //}



            MetrixUtilities.joinCurves(doc.Layers.Find("PANEL PERIMETER", true));
            if (panel.FixingHoles == "1")
            {
                //if fixing holes are not manipulated, recalculate distances
                if (!fixingHolesManipulated)
                {
                    //panel = reCalculateDistances(panel);

                    //Below method is if fixing holes are automated
                    guidList = FixingHoles.drawFixingFoles(panel, null, false, 0, 0, panelY0, panelY1, dimStyle, guidList, panelX0, panelX1, 0, 0, 0, 0, 0); //add fixing holes
                }
                else
                {
                    //Below method is if fixing holes  have been manipulated
                    guidList = CustomFixingHoles.drawFixingFoles(panel, null, false, 0, 0, panelY0, panelY1, dimStyle, guidList, panelX0, panelX1, 0, 0, 0, 0, 0); //add fixing holes
                }
            }
            layerName  = "VIEWPORT";
            layerIndex = createSubLayers.createSubLayer(layerName,
                                                        System.Drawing.Color.Black, parent_layer_Approval); //pass to the method, make Approval layer the parent layer

            doc.Layers.SetCurrentLayerIndex(layerIndex, true);

            foreach (Guid g in guidList)
            {
                int idx = RhinoDoc.ActiveDoc.Groups.Find(panel.PartName, false);

                if (idx < 0)
                {
                    idx = RhinoDoc.ActiveDoc.Groups.Add(panel.PartName);
                }

                RhinoDoc.ActiveDoc.Groups.AddToGroup(idx, g);
            }

            //end
        }
コード例 #28
0
ファイル: Leader.cs プロジェクト: wieslawsoltes/netDxf
 /// <summary>
 /// Initializes a new instance of the <c>Leader</c> class.
 /// </summary>
 /// <param name="block">Leader block annotation.</param>
 /// <param name="vertexes">List of leader vertexes in local coordinates.</param>
 /// <param name="style">Leader style.</param>
 public Leader(Block block, IEnumerable <Vector2> vertexes, DimensionStyle style)
     : this(vertexes, style)
 {
     this.Annotation = this.BuildAnnotation(block);
 }
コード例 #29
0
        /// <summary>
        /// Initializes a new instance of the <c>DiametricDimension</c> class.
        /// </summary>
        /// <param name="centerPoint">Center <see cref="Vector2">point</see> of the circumference.</param>
        /// <param name="referencePoint"><see cref="Vector2">Point</see> on circle or arc.</param>
        /// <param name="offset">Distance between the reference point and the dimension text</param>
        /// <param name="style">The <see cref="DimensionStyle">style</see> to use with the dimension.</param>
        /// <remarks>The center point and the definition point define the distance to be measure.</remarks>
        public DiametricDimension(Vector2 centerPoint, Vector2 referencePoint, double offset, DimensionStyle style)
            : base(DimensionType.Diameter)
        {
            this.center   = centerPoint;
            this.refPoint = referencePoint;

            if (offset < 0.0)
            {
                throw new ArgumentOutOfRangeException(nameof(offset), "The offset value cannot be negative.");
            }
            this.offset = offset;

            if (style == null)
            {
                throw new ArgumentNullException(nameof(style));
            }
            this.Style = style;
        }
コード例 #30
0
        /// <summary>
        /// Initializes a new instance of the <c>LinearDimension</c> class.
        /// </summary>
        /// <param name="referenceLine">Reference <see cref="Line">line</see> of the dimension.</param>
        /// <param name="offset">Distance between the reference line and the dimension line.</param>
        /// <param name="rotation">Rotation in degrees of the dimension line.</param>
        /// <param name="normal">Normal vector of the plane where the dimension is defined.</param>
        /// <param name="style">The <see cref="DimensionStyle">style</see> to use with the dimension.</param>
        /// <remarks>The reference line define the distance to be measure.</remarks>
        public LinearDimension(Line referenceLine, double offset, double rotation, Vector3 normal, DimensionStyle style)
            : base(DimensionType.Linear)
        {
            if (referenceLine == null)
            {
                throw new ArgumentNullException(nameof(referenceLine));
            }

            Vector3 ocsPoint;

            ocsPoint            = MathHelper.Transform(referenceLine.StartPoint, normal, CoordinateSystem.World, CoordinateSystem.Object);
            this.firstRefPoint  = new Vector2(ocsPoint.X, ocsPoint.Y);
            ocsPoint            = MathHelper.Transform(referenceLine.EndPoint, normal, CoordinateSystem.World, CoordinateSystem.Object);
            this.secondRefPoint = new Vector2(ocsPoint.X, ocsPoint.Y);
            this.offset         = offset;
            this.rotation       = MathHelper.NormalizeAngle(rotation);

            if (style == null)
            {
                throw new ArgumentNullException(nameof(style));
            }
            this.Style     = style;
            this.Normal    = normal;
            this.Elevation = ocsPoint.Z;
        }