예제 #1
0
        protected override Result RunCommand(RhinoDoc doc, RunMode mode)
        {
            // Check the selected curve
            GetObject go = new GetObject();

            go.GroupSelect     = true;
            go.SubObjectSelect = false;
            go.EnableClearObjectsOnEntry(false);
            go.EnableUnselectObjectsOnExit(false);
            go.DeselectAllBeforePostSelect = false;
            go.EnableSelPrevious(true);
            go.EnablePreSelect(true, false);
            go.GeometryFilter = Rhino.DocObjects.ObjectType.Curve;

            GetResult result = go.Get();

            if (go.CommandResult() != Rhino.Commands.Result.Success)
            {
                return(go.CommandResult());
            }

            if (go.ObjectCount != 1)
            {
                RhinoApp.WriteLine("Error: {0} curve is selected.", go.ObjectCount);
                return(Rhino.Commands.Result.Failure);
            }

            RhinoApp.WriteLine("{0} curve is selected.", go.ObjectCount);

            Curve curve = go.Object(0).Curve();

            // If curve is null
            if (curve == null)
            {
                return(Rhino.Commands.Result.Failure);
            }

            // If curve is Closed Curve Orientation
            if (curve.IsClosed == false)
            {
                RhinoApp.WriteLine("The curve is open");
                return(Rhino.Commands.Result.Failure);
            }
            RhinoUtilities.SetActiveLayer(Properties.Settings.Default.PerforationLayerName, System.Drawing.Color.Green);
            PerforationForm perforationForm = new PerforationForm(curve);

            perforationForm.ShowDialog(RhinoApp.MainWindow());
            RhinoDoc.ActiveDoc.Views.Redraw();
            return(Result.Success);
        }
        /// <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
        }
        protected override Result RunCommand(RhinoDoc doc, RunMode mode)
        {
            string selectedLayer;
            Color  selectedColour;

            // For this example we will use a GetPoint class, but all of the custom
            // "Get" classes support command line options.
            Rhino.Input.Custom.GetObject go = new Rhino.Input.Custom.GetObject();
            go.SetCommandPrompt("Select panels to create borders");

            double border = Properties.Settings.Default.PanelBorderDefault; // Default borderSize is 50

            // set up the options
            Rhino.Input.Custom.OptionDouble borderSizeOption = new Rhino.Input.Custom.OptionDouble(border);

            go.AddOptionDouble("Borders", ref borderSizeOption);
            go.AcceptNumber(true, true);
            go.GeometryFilter  = Rhino.DocObjects.ObjectType.Curve;
            go.GroupSelect     = true;
            go.SubObjectSelect = false;
            go.EnableClearObjectsOnEntry(false);
            go.EnableUnselectObjectsOnExit(false);
            go.DeselectAllBeforePostSelect = false;
            go.EnableSelPrevious(true);
            go.EnablePreSelect(true, false);

            go.GeometryFilter = Rhino.DocObjects.ObjectType.Curve;


            RequiredLayer getRequiredLayer = new RequiredLayer();

            getRequiredLayer.ShowDialog();
            selectedLayer  = getRequiredLayer.getLayerName();
            selectedColour = getRequiredLayer.getSelectedColor();
            while (true)
            {
                go.ClearCommandOptions();
                borderSizeOption = new Rhino.Input.Custom.OptionDouble(border);
                go.AddOptionDouble("Borders", ref borderSizeOption);
                // perform the get operation. This will prompt the user to select the list of curves, but also
                // allow for command line options defined above
                GetResult result = go.GetMultiple(1, 0);

                if (result == GetResult.Option)
                {
                    border = borderSizeOption.CurrentValue;
                    go.EnablePreSelect(false, true);
                    continue;
                }
                else if (result == GetResult.Number)
                {
                    border = go.Number();
                    continue;
                }
                else if (result != GetResult.Object)
                {
                    return(Result.Cancel);
                }

                if (go.ObjectsWerePreselected)
                {
                    go.EnablePreSelect(false, true);
                    continue;
                }

                break;
            }

            int objecTCount = go.ObjectCount;

            border = borderSizeOption.CurrentValue;

            foreach (ObjRef objRef in go.Objects())
            {
                Curve curve = objRef.Curve();

                // If curve is null, means objRef is not a curve
                if (curve == null)
                {
                    continue;
                }

                // If curve is not Closed Curve
                if (curve.IsClosed == false)
                {
                    RhinoApp.WriteLine(objRef.ToString() + " curve is open");
                    continue;
                }

                if (curve.IsPlanar() == false)
                {
                    RhinoApp.WriteLine(objRef.ToString() + " curve is not planar");
                    continue;
                }

                // Process the curve
                Plane   plane = Rhino.Geometry.Plane.WorldXY;
                Curve[] offsetCurves;

                int layerIndex = doc.Layers.CurrentLayerIndex;
                RhinoUtilities.SetActiveLayer(selectedLayer, selectedColour);

                //if (curve.TryGetPlane(out plane))
                //{
                if (border < 0) //If the border is negative, it means the border should be drawn outside the perimeter
                {
                    plane.XAxis = -plane.XAxis;
                    plane.YAxis = -plane.YAxis;
                    plane.ZAxis = -plane.ZAxis;

                    offsetCurves = curve.Offset(plane, border, 0.1, Rhino.Geometry.CurveOffsetCornerStyle.Sharp);
                }
                else
                {
                    offsetCurves = curve.Offset(plane, -border, 0.1, Rhino.Geometry.CurveOffsetCornerStyle.Sharp);
                }

                //Check if the curve is outside border and border is a positive
                if (curve.Contains(offsetCurves[0].PointAtStart, Plane.WorldXY, 0) == PointContainment.Outside && border > 0)
                {
                    offsetCurves = curve.Offset(plane, border, 0.1, Rhino.Geometry.CurveOffsetCornerStyle.Sharp); //if true, then try to set the curve to be within the border
                }

                //Check if the curve is within the border and border is a negative
                if (curve.Contains(offsetCurves[0].PointAtStart, Plane.WorldXY, 0) == PointContainment.Inside && border < 0)
                {
                    offsetCurves = curve.Offset(plane, -border, 0.1, Rhino.Geometry.CurveOffsetCornerStyle.Sharp); //if true, then try to set the curve to be outside the border
                }

                foreach (Curve c in offsetCurves)
                {
                    doc.Objects.AddCurve(c);
                }


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

            doc.Views.Redraw();

            Properties.Settings.Default.PanelBorderDefault = border;
            Properties.Settings.Default.Save();

            return(Result.Success);
        }
        protected override Result RunCommand(RhinoDoc doc, RunMode mode)
        {
            // For this example we will use a GetPoint class, but all of the custom
            // "Get" classes support command line options.
            Rhino.Input.Custom.GetObject go = new Rhino.Input.Custom.GetObject();
            go.SetCommandPrompt("Select panels to create fixing holes");
            //get the default values for the properties
            double holeSize   = Properties.Settings.Default.FixingHoleSize;
            double offsetX    = Properties.Settings.Default.FixingHoleOffsetX;
            double offsetY    = Properties.Settings.Default.FixingHoleOffsetY;
            double spacing    = Properties.Settings.Default.FixingHoleSpacing;
            double minSpacing = Properties.Settings.Default.FixingHoleMinimum;

            // set up the options
            Rhino.Input.Custom.OptionDouble holeSizeOption   = new Rhino.Input.Custom.OptionDouble(holeSize);
            Rhino.Input.Custom.OptionDouble offsetXOption    = new Rhino.Input.Custom.OptionDouble(offsetX);
            Rhino.Input.Custom.OptionDouble offsetYOption    = new Rhino.Input.Custom.OptionDouble(offsetY);
            Rhino.Input.Custom.OptionDouble spacingOption    = new Rhino.Input.Custom.OptionDouble(spacing);
            Rhino.Input.Custom.OptionDouble minSpacingOption = new Rhino.Input.Custom.OptionDouble(minSpacing);


            //using option to get values and save automatically(only if user enters)
            go.AddOptionDouble("HoleSize", ref holeSizeOption);
            go.AddOptionDouble("OffsetX", ref offsetXOption);
            go.AddOptionDouble("OffsetY", ref offsetYOption);
            go.AddOptionDouble("Spacing", ref spacingOption);
            go.AddOptionDouble("MinSpacing", ref minSpacingOption);

            go.AcceptNumber(true, true);
            go.GeometryFilter  = Rhino.DocObjects.ObjectType.Curve;
            go.GroupSelect     = true;
            go.SubObjectSelect = false;
            go.EnableClearObjectsOnEntry(false);
            go.EnableUnselectObjectsOnExit(false);
            go.DeselectAllBeforePostSelect = false;
            go.EnableSelPrevious(true);
            go.EnablePreSelect(true, false);

            go.GeometryFilter = Rhino.DocObjects.ObjectType.Curve;

            while (true)
            {
                go.ClearCommandOptions();
                holeSizeOption   = new Rhino.Input.Custom.OptionDouble(holeSize);
                offsetXOption    = new Rhino.Input.Custom.OptionDouble(offsetX);
                offsetYOption    = new Rhino.Input.Custom.OptionDouble(offsetY);
                spacingOption    = new Rhino.Input.Custom.OptionDouble(spacing);
                minSpacingOption = new Rhino.Input.Custom.OptionDouble(minSpacing);

                go.AddOptionDouble("HoleSize", ref holeSizeOption);
                go.AddOptionDouble("OffsetX", ref offsetXOption);
                go.AddOptionDouble("OffsetY", ref offsetYOption);
                go.AddOptionDouble("Spacing", ref spacingOption);
                go.AddOptionDouble("MinSpacing", ref minSpacingOption);
                // perform the get operation. This will prompt the user to select the list of curves, but also
                // allow for command line options defined above
                GetResult result = go.GetMultiple(1, 0);

                if (result == GetResult.Option)
                {
                    holeSize   = holeSizeOption.CurrentValue;
                    offsetX    = offsetXOption.CurrentValue;
                    offsetY    = offsetYOption.CurrentValue;
                    spacing    = spacingOption.CurrentValue;
                    minSpacing = minSpacingOption.CurrentValue;
                    go.EnablePreSelect(false, true);
                    continue;
                }
                //else if (result == GetResult.Number)
                //{
                //   border = go.Number();
                //   continue;
                //}
                else if (result != GetResult.Object)
                {
                    return(Result.Cancel);
                }

                if (go.ObjectsWerePreselected)
                {
                    go.EnablePreSelect(false, true);
                    continue;
                }

                break;
            }

            int objecTCount = go.ObjectCount;

            foreach (ObjRef objRef in go.Objects())
            {
                Curve curve = objRef.Curve();

                // If curve is null, means objRef is not a curve
                if (curve == null)
                {
                    continue;
                }

                // If curve is not Closed Curve
                if (curve.IsClosed == false)
                {
                    RhinoApp.WriteLine(objRef.ToString() + " curve is open");
                    continue;
                }

                if (curve.IsPlanar() == false)
                {
                    RhinoApp.WriteLine(objRef.ToString() + " curve is not planar");
                    continue;
                }


                // Find the boundary
                BoundingBox boundingBox = curve.GetBoundingBox(Plane.WorldXY);
                Point3d     min         = boundingBox.Min;
                Point3d     max         = boundingBox.Max;

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

                // Calculate top and bottom fixing holes
                double runningX = min.X + offsetX; //25
                double runningY = max.Y - offsetY; //-626.5

                Point3d point;

                while (runningX < (max.X - offsetX) - minSpacing)
                {
                    point = new Point3d(runningX, runningY, 0);
                    pointsList.Add(point);

                    point = new Point3d(runningX, min.Y + offsetY, 0);
                    pointsList.Add(point);

                    runningX = runningX + spacing;
                }

                point = new Point3d(max.X - offsetX, runningY, 0); //adds the top right fixing hole
                pointsList.Add(point);

                point = new Point3d(max.X - offsetX, min.Y + offsetY, 0); //adds the bottom right fixing hole
                pointsList.Add(point);

                runningY = runningY - spacing;

                // Calculate the sides
                while (runningY > (min.Y - offsetY) + minSpacing)
                {
                    point = new Point3d(min.X + offsetX, runningY, 0); //adds the left fixing holes
                    pointsList.Add(point);

                    point = new Point3d(max.X - offsetX, runningY, 0); //adds the right fixing hole
                    pointsList.Add(point);

                    runningY = runningY - spacing;
                }

                // Process the curve
                Plane plane = Rhino.Geometry.Plane.WorldXY;

                int layerIndex = doc.Layers.CurrentLayerIndex;

                RhinoUtilities.SetActiveLayer("Fixing Holes", System.Drawing.Color.Black);

                // Draw all the holes
                Round round = new Round();
                round.X = holeSize;


                foreach (Point3d p in pointsList)
                {
                    round.drawTool(p);
                }

                //Round round = new Round();
                //round.X = holeSize;
                //round.drawTool(point);


                //offsetCurves = curve.Offset(plane, -border, 0.1, Rhino.Geometry.CurveOffsetCornerStyle.Sharp);

                //if (curve.Contains(offsetCurves[0].PointAtStart, Plane.WorldXY, 0) == PointContainment.Outside)
                //{
                //   offsetCurves = curve.Offset(plane, border, 0.1, Rhino.Geometry.CurveOffsetCornerStyle.Sharp);
                //}


                //foreach (Curve c in offsetCurves)
                //{
                //   doc.Objects.AddCurve(c);
                //}
                //// }

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

            doc.Views.Redraw();

            Properties.Settings.Default.FixingHoleSize    = holeSize;
            Properties.Settings.Default.FixingHoleOffsetX = offsetX;
            Properties.Settings.Default.FixingHoleOffsetY = offsetY;
            Properties.Settings.Default.FixingHoleSpacing = spacing;
            Properties.Settings.Default.FixingHoleMinimum = minSpacing;
            Properties.Settings.Default.Save();

            return(Result.Success);
        }
        protected override Result RunCommand(RhinoDoc doc, RunMode mode)
        {
            string fontName = "Dot-Matrix";
            float  fontSize = 12;

            using (System.Drawing.Font fontTester = new System.Drawing.Font(fontName, fontSize))
            {
                if (fontTester.Name == fontName)
                {
                    // Font exists do nothing
                }
                else
                {
                    RhinoApp.WriteLine("Dot Matrix Font does not exist, press install to install the font. Restart Rhino after installation.");

                    string assemblyFolder = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);

                    Process.Start(assemblyFolder + @"\Fonts\dotmat_0.ttf");

                    return(Rhino.Commands.Result.Failure);
                }
            }

            // Check the selected dot
            GetObject go = new GetObject();

            go.GroupSelect     = true;
            go.SubObjectSelect = false;
            go.EnableClearObjectsOnEntry(false);
            go.EnableUnselectObjectsOnExit(false);
            go.DeselectAllBeforePostSelect = false;
            go.EnableSelPrevious(true);
            go.EnablePreSelect(true, false);
            go.GeometryFilter = Rhino.DocObjects.ObjectType.Point | Rhino.DocObjects.ObjectType.Annotation;

            go.SetCommandPrompt("Select Label and a point:");
            GetResult result = go.GetMultiple(2, -1);

            if (go.CommandResult() != Rhino.Commands.Result.Success)
            {
                return(go.CommandResult());
            }

            RhinoApp.WriteLine("Object selection counter = {0}", go.ObjectCount);

            Point      pt           = null;
            TextEntity textEntity   = null;
            int        pointCounter = 0;
            int        textCounter  = 0;


            // Loop through all the objects to find Text
            for (int i = 0; i < go.ObjectCount; i++)
            {
                RhinoObject rhinoObject = go.Object(i).Object();

                if (rhinoObject.ObjectType == ObjectType.Annotation)
                {
                    textEntity = rhinoObject.Geometry as TextEntity;

                    if (textEntity != null && textCounter == 0)
                    {
                        textCounter++;
                    }
                }
                else if (rhinoObject.ObjectType == ObjectType.Point)
                {
                    pt = rhinoObject.Geometry as Point;

                    if (pt != null && pointCounter == 0)
                    {
                        pointCounter++;
                    }
                }
            }



            //if (go.Object(0).Point() != null && go.Object(1).TextEntity() != null)
            //{
            //   pt = go.Object(0).Point();
            //   textEntity = go.Object(1).TextEntity();
            //}
            //else if (go.Object(1).Point() != null && go.Object(0).TextEntity() != null)
            //{
            //   pt = go.Object(1).Point();
            //   textEntity = go.Object(0).TextEntity();
            //}
            //else
            //{
            //   RhinoApp.WriteLine("Two of the same objects are selected.");
            //   return Result.Failure;
            //}

            if (textCounter > 1)
            {
                RhinoApp.WriteLine("More than one text has been selected.");
            }

            if (pointCounter > 1)
            {
                RhinoApp.WriteLine("More than one point has been selected.");
            }


            // Record the current layer
            int currentLayer = doc.Layers.CurrentLayerIndex;

            // Set the layer to perforation
            RhinoUtilities.SetActiveLayer(Properties.Settings.Default.DotFontLayerName, System.Drawing.Color.Black);

            if (pt != null && textEntity != null)
            {
                drawDotMatrix(pt.Location, textEntity.Text, Properties.Settings.Default.DotMatrixHeight, 80);
            }

            doc.Layers.SetCurrentLayerIndex(currentLayer, true);

            doc.Views.Redraw();

            return(Result.Success);
        }
        protected override Result RunCommand(RhinoDoc doc, RunMode mode)
        {
            // Open file dialog
            OpenFileDialog openFileDialog = new OpenFileDialog();

            openFileDialog.InitialDirectory = doc.Path;
            openFileDialog.Filter           = "3dm files (*.3dm)|*.3dm| dxf files (*.dxf)|*.dxf|All files (*.*)|*.*";
            openFileDialog.FilterIndex      = 2;
            openFileDialog.RestoreDirectory = true;
            openFileDialog.Multiselect      = true;
            openFileDialog.Title            = "CAD files to merge";

            DialogResult dr = openFileDialog.ShowDialog();
            uint         firstSN, lastSN;
            string       sScript;
            BoundingBox  bbox;
            string       panelDetails = "";

            double             importMinX, importMinY;
            double             importMaxX, importMaxY;
            double             globalMinX, globalMinY;
            double             globalMaxX, globalMaxY;
            double             gap          = 500;
            Boolean            executedOnce = false;
            double             commonminY   = 0;
            double             commonminX   = 0;
            double             commonmaxY   = 0;
            List <RhinoObject> imported     = new List <RhinoObject>(); //holds the imported rhino obects (all objects)
            List <RhinoObject> oldObjs      = new List <RhinoObject>(); //holds the old objects in the document
            List <RhinoObject> newObjs      = new List <RhinoObject>(); //holds the new objects in the document
            Boolean            newObjFound  = false;

            if (dr == System.Windows.Forms.DialogResult.OK)
            {
                //Select direction and angle
                double            rotationAngle = 0;
                bool              anticlockwise = true;
                MessageBoxButtons buttons       = MessageBoxButtons.YesNo;

                DialogResult result = MessageBox.Show("Do you want to rotate each dxf imported by 90°?", "DXF rotation", buttons);
                if (result == DialogResult.Yes)
                {
                    rotationAngle = 90;
                    result        = MessageBox.Show("Select the rotation direction: 'Yes' for 'Anti-clockwise' and 'No' for 'Clockwise'.", "Rotation Direction", buttons);
                    if (result == DialogResult.No)
                    {
                        rotationAngle = -90;
                        anticlockwise = false;
                    }
                }



                // Read the files
                foreach (String file in openFileDialog.FileNames)
                {
                    importMinX = Double.MaxValue;
                    importMinY = Double.MaxValue;
                    importMaxX = Double.MinValue;
                    importMaxY = Double.MinValue;
                    globalMinX = Double.MaxValue;
                    globalMinY = Double.MaxValue;
                    globalMaxX = Double.MinValue;
                    globalMaxY = Double.MinValue;

                    // Import each file
                    try
                    {
                        sScript = String.Format("! _-Import \"{0}\" _Enter", file);

                        firstSN = RhinoObject.NextRuntimeSerialNumber;
                        RhinoApp.RunScript(sScript, false);
                        lastSN = RhinoObject.NextRuntimeSerialNumber; //Investigate later
                        List <Guid> ids = new List <Guid>();
                        imported = new List <RhinoObject>();
                        newObjs  = new List <RhinoObject>();
                        foreach (RhinoObject obj in doc.Objects)
                        {
                            if (obj.RuntimeSerialNumber >= firstSN && obj.RuntimeSerialNumber < lastSN)
                            {
                                imported.Add(obj);
                                ids.Add(obj.Id);

                                bbox = obj.Geometry.GetBoundingBox(Plane.WorldXY);

                                if (importMaxX < bbox.Max.X)
                                {
                                    importMaxX = bbox.Max.X;
                                }

                                if (importMaxY < bbox.Max.Y)
                                {
                                    importMaxY = bbox.Max.Y;
                                }

                                if (importMinX > bbox.Min.X)
                                {
                                    importMinX = bbox.Min.X;
                                }

                                if (importMinY > bbox.Min.Y)
                                {
                                    importMinY = bbox.Min.Y;
                                }
                            }
                            else
                            {
                                //Global
                                bbox = obj.Geometry.GetBoundingBox(Plane.WorldXY);

                                if (globalMaxX < bbox.Max.X)
                                {
                                    globalMaxX = bbox.Max.X;
                                }

                                if (globalMaxY < bbox.Max.Y)
                                {
                                    globalMaxY = bbox.Max.Y;
                                }

                                if (globalMinX > bbox.Min.X)
                                {
                                    globalMinX = bbox.Min.X;
                                }

                                if (globalMinY > bbox.Min.Y)
                                {
                                    globalMinY = bbox.Min.Y;
                                }
                            }
                        }

                        if (!executedOnce) //execute this only once
                        {
                            commonminY = importMinY;
                            commonminX = importMinX;
                            commonmaxY = importMaxY;
                        }

                        var startPoint = new Point3d(importMinX, importMinY, 0);

                        if (globalMaxX == Double.MinValue)
                        {
                            globalMaxX = 0;
                        }
                        if (globalMaxY == Double.MinValue)
                        {
                            globalMaxY = 0;
                        }
                        if (globalMinX == Double.MaxValue)
                        {
                            globalMinX = 0;
                        }
                        if (globalMinY == Double.MaxValue)
                        {
                            globalMinY = 0;
                        }


                        var endPoint = new Point3d(globalMaxX + gap, commonminY, 0);

                        List <string> names = new List <string>();
                        //find which type of perimeter
                        for (int i = 0; i < 100; i++)
                        {
                            if (doc.Layers.FindIndex(i) != null)
                            {
                                names.Add(doc.Layers.FindIndex(i).Name);
                            }
                            else
                            {
                                break;
                            }
                        }

                        /*
                         * String perimeterName = "Default";
                         * //Get the correct perimeter name
                         * if (doc.Layers.Find("LAYERS_FOR_NESTING$PANEL_P", true) >= 0)
                         * {
                         *  perimeterName = "LAYERS_FOR_NESTING$PANEL_P";
                         * }
                         *
                         * if (doc.Layers.Find("Panel_Perimeter", true) >= 0)
                         * {
                         *  perimeterName = "Panel_Perimeter";
                         * }  */

                        int layer_index = doc.Layers.Find("PANEL PERIMETER", true);
                        if (layer_index < 0)
                        {
                            // Add a new layer to the document
                            layer_index = doc.Layers.Add("PANEL PERIMETER", System.Drawing.Color.Black);
                        }


                        foreach (string perimeterName in names)
                        {
                            foreach (RhinoObject obj in doc.Objects.FindByLayer(perimeterName))
                            {
                                ObjRef objR = new ObjRef(obj);
                                if (objR.Curve() == null)
                                {
                                    continue;
                                }
                                //loop through the old objects array to find if the object is found in the array
                                foreach (RhinoObject rhinObj in oldObjs)
                                {
                                    if (rhinObj.Id.Equals(obj.Id)) //if the ids are equals it means the object belongs to a panel which has already been rotated
                                    {
                                        newObjFound = true;        //set to true
                                        break;                     //exit from this second loop
                                    }
                                }
                                if (!newObjFound)     //go in only if the newObjectfound is false
                                {
                                    newObjs.Add(obj); //add the new object to the array
                                }
                                newObjFound = false;  //set the variable back to false
                            }
                        }



                        // Move all the objects
                        var xform = Transform.Translation(endPoint - startPoint);
                        foreach (var objRef in imported)
                        {
                            doc.Objects.Transform(objRef, xform, true);
                        }

                        executedOnce = true;

                        Rhino.Geometry.Point3d pt    = new Rhino.Geometry.Point3d(globalMaxX + gap, (commonminY + commonmaxY) / 2, 0);
                        Rhino.Geometry.Plane   plane = doc.Views.ActiveView.ActiveViewport.ConstructionPlane();
                        plane.Origin = pt;
                        String dimension = findLeastDimension(newObjs, plane, "PANEL PERIMETER", rotationAngle); //call the method and pass the parameters to find the min X and min Y for the panel


                        // Add the file as the label

                        //The codes below are to create red labels for each panel

                        double height = (importMaxY - importMinY) * 0.1;
                        //double height = 3;
                        string label      = Path.GetFileNameWithoutExtension(file);
                        int    layerIndex = doc.Layers.CurrentLayerIndex;

                        RhinoUtilities.SetActiveLayer("LABELS", System.Drawing.Color.Red);

                        const string font = "Arial";
                        plane        = doc.Views.ActiveView.ActiveViewport.ConstructionPlane();
                        plane.Origin = pt;
                        Guid labelGuid = doc.Objects.AddText(label, plane, height, font, false, false);

                        ids.Add(labelGuid);
                        imported.Add(doc.Objects.Find(labelGuid));

                        doc.Layers.SetCurrentLayerIndex(layerIndex, true);

                        //panelDetails = panelDetails + label + "\t" + (importMaxX - importMinX) + "\t" + (importMaxY - importMinY) + "\n";
                        panelDetails = panelDetails + label + "#" + dimension + "\n"; //set the dimension with the panel name                                                                                                                                                                                                                                                                             vv



                        //int index = doc.Groups.Add(ids);

                        oldObjs.AddRange(newObjs);
                    }
                    catch (Exception ex)
                    {
                        // Could not load the image - probably related to Windows file system permissions.
                        MessageBox.Show(ex.Message);
                    }
                }


                double labelHeight = 100;
                Rhino.Geometry.Point3d panelDetailsPt    = new Rhino.Geometry.Point3d(0, 0 + labelHeight, 0);
                const string           labelFont         = "Arial";
                Rhino.Geometry.Plane   panelDetailsPlane = doc.Views.ActiveView.ActiveViewport.ConstructionPlane();
                panelDetailsPlane.Origin = panelDetailsPt;
                doc.Objects.AddText(panelDetails, panelDetailsPlane, labelHeight, labelFont, false, false);

                doc.Layers.Delete(doc.Layers.Find("temp", false), true);

                exportToExcel(panelDetails); //call to export panel dimensions to excel
            }

            Messages.excelOperationComplete();

            // Export the whole lot
            //string command = string.Format("-_Export \"" + Path.GetDirectoryName(doc.Path) + @"\" + labelName + "\"  Scheme \"R12 Lines & Arcs\" Enter");
            // Export the selected curves
            //RhinoApp.RunScript(command, true);
            doc.Views.Redraw();
            return(Result.Success);
        }
        public String findLeastDimension(List <RhinoObject> newObjs, Plane plane, String perimeterName, double rotationAngle)
        {
            RhinoDoc doc        = RhinoDoc.ActiveDoc;
            double   minX       = 0;
            double   minY       = 0;
            double   minArea    = double.MaxValue;
            Layer    layerIndex = doc.Layers.FindName("Default");

            RhinoUtilities.SetActiveLayer("temp", System.Drawing.Color.Black);
            //Copy Objects of current layer to temp layer
            foreach (var selected_object in newObjs)
            {
                selected_object.Attributes.LayerIndex = doc.Layers.Find("temp", false);
                selected_object.CommitChanges();
            }
            //select objects in the temporart layer and join
            RhinoApp.RunScript("SelNone", true);
            RhinoApp.RunScript("SelLayerNumber " + doc.Layers.Find("temp", true), false);
            //MetrixUtilities.joinCurves(doc.Layers.Find("temp", false));


            //plane.Rotate(i, plane.XAxis); //rotateshape with the value of i
            RhinoObject[] objs      = doc.Objects.FindByLayer("temp");
            List <Curve>  curveList = new List <Curve>();

            Curve[]     curveArray = null;
            RhinoObject obj        = objs[0];

            foreach (RhinoObject objt in objs)
            {
                curveList.Add(new ObjRef(objt).Curve());
            }
            curveArray = Curve.JoinCurves(curveList);



            obj.Attributes.ToString();
            ObjRef objR        = new ObjRef(obj);
            Curve  curve       = objR.Curve();
            double curvelength = -1;
            Curve  baseline    = null;
            double angle       = 0;

            foreach (Curve cv in curveList)
            {
                if (cv.GetLength() > curvelength)
                {
                    curvelength = cv.GetLength();
                    baseline    = cv;
                    angle       = Math.Atan(baseline.TangentAtStart.Y / baseline.TangentAtStart.X);
                }
            }

            if (curveArray != null)
            {
                double maxArea = Double.MinValue;
                foreach (Curve tempCurve in curveArray)
                {
                    BoundingBox tempBBox = tempCurve.GetBoundingBox(true);
                    if (tempBBox.Area > maxArea)
                    {
                        curve = tempCurve;
                    }
                }
            }
            BoundingBox    boundingBox    = curve.GetBoundingBox(Plane.WorldXY);
            List <Point3d> points         = new List <Point3d>();
            PolylineCurve  polyline_curve = curve as PolylineCurve;
            double         diagnal        = 0;
            bool           rectangle      = false;
            Point3d        centerC        = boundingBox.Center;

            minArea = boundingBox.Area;
            minX    = boundingBox.Max.X - boundingBox.Min.X;
            minY    = boundingBox.Max.Y - boundingBox.Min.Y;

            /*
             * if (polyline_curve != null && polyline_curve.PointCount == 5)
             * {
             *  for (int j = 0; j < polyline_curve.PointCount; j++)
             *  {
             *      points.Add(polyline_curve.Point(j));
             *  }
             *
             *  if(Math.Round(points[0].DistanceTo(points[1])) == Math.Round(points[2].DistanceTo(points[3])))
             *  {
             *      minX = points[0].DistanceTo(points[1]);
             *      minY = points[1].DistanceTo(points[2]);
             *      rectangle = true;
             *  }
             *  else
             *  {
             *      rectangle = false;
             *  }
             * }*/

            if (rectangle == false)
            {
                curve.Rotate(-angle, Plane.WorldXY.ZAxis, baseline.PointAtStart);
                boundingBox = curve.GetBoundingBox(Plane.WorldXY);
                if (boundingBox.Area < minArea)
                {
                    Point3d min = boundingBox.Min;
                    Point3d max = boundingBox.Max;
                    minX = max.X - min.X;
                    minY = max.Y - min.Y;
                }
            }


            RhinoApp.RunScript("-_Rotate " + centerC + " " + rotationAngle, false);


            //RhinoApp.RunScript("-_Rotate " + boundingBox.Center +" " + 5, false);



            //Set back the previous default layer
            RhinoUtilities.SetActiveLayer(perimeterName, System.Drawing.Color.Black);
            //Copy all object of temp layer back to the previous layer
            foreach (var selected_object in doc.Objects.FindByLayer("temp"))
            {
                selected_object.Attributes.LayerIndex = doc.Layers.FindByFullPath(perimeterName, false);
                selected_object.CommitChanges();
            }

            doc.Layers.SetCurrentLayerIndex(doc.Layers.FindByFullPath(layerIndex.Name, false), true);
            //needs to fix the tab issue
            return(String.Format("{0}#{1}", Math.Max(minX, minY), Math.Min(minX, minY))); //return the minX and minY for the panel
        }