C# Rectangle.Clone方法代码示例

        /// <summary>
        /// Fit rectangles into a given width. Total height required is returned
        /// </summary>
        public int AlgFillByStripes(int binWidth, Rectangle[] rects)
        {
            // Sort by height.
            var bestRects = (Rectangle[])rects.Clone();
            Array.Sort(bestRects, new HeightComparer());

            // Make variables to track and record the best solution.
            var isPositioned = new bool[bestRects.Length];
            var numUnpositioned = bestRects.Length;

            // Fill by stripes.
            int maxY = 0;
            for (int i = 0; i <= rects.Length - 1; i++) {
                // See if this rectangle is positioned.
                if (!isPositioned[i]) {
                    // Start a new stripe.
                    numUnpositioned -= 1;
                    isPositioned[i] = true;
                    bestRects[i].X = 0;
                    bestRects[i].Y = maxY;

                    FillBoundedArea(
                        bestRects[i].Width, binWidth, maxY,
                        maxY + bestRects[i].Height,
                        ref numUnpositioned, ref bestRects, ref isPositioned);

                    if (numUnpositioned == 0) break;
                    maxY += bestRects[i].Height;
                }
            }

            // Save the best solution.
            Array.Copy(bestRects, rects, rects.Length);
            return maxY;
        }

        // Start the recursion.
        public void AlgFillByStripes(int bin_width, Rectangle[] rects)
        {
            // Sort by height.
            Rectangle[] best_rects = (Rectangle[])rects.Clone();
            Array.Sort(best_rects, new HeightComparer());

            // Make variables to track and record the best solution.
            bool[] is_positioned = new bool[best_rects.Length];
            int num_unpositioned = best_rects.Length;

            // Fill by stripes.
            int max_y = 0;
            for (int i = 0; i <= rects.Length - 1; i++)
            {
                // See if this rectangle is positioned.
                if (!is_positioned[i])
                {
                    // Start a new stripe.
                    num_unpositioned -= 1;
                    is_positioned[i] = true;
                    best_rects[i].X = 0;
                    best_rects[i].Y = max_y;

                    FillBoundedArea(
                        best_rects[i].Width, bin_width, max_y,
                        max_y + best_rects[i].Height,
                        ref num_unpositioned, ref best_rects, ref is_positioned);

                    if (num_unpositioned == 0) break;
                    max_y += best_rects[i].Height;
                }
            }

            // Save the best solution.
            Array.Copy(best_rects, rects, rects.Length);
        }

        static void CreateFromLayer(XmlTextWriter xtw, Layer layer, Rectangle extents)
        {
            ProjFourWrapper src = null;
            ProjFourWrapper dst = null;
            Rectangle queryExtents = extents.Clone();

            try
            {

                if (!string.IsNullOrEmpty(layer.Projection) &&
                    layer.Projection != ProjFourWrapper.WGS84)
                {
                    src = new ProjFourWrapper(layer.Projection);
                    dst = new ProjFourWrapper(ProjFourWrapper.WGS84);

                    queryExtents = new Rectangle(dst.Transform(src, queryExtents.Min),
                                                    dst.Transform(src, queryExtents.Max));
                }

                xtw.WriteStartElement("Folder");
                xtw.WriteElementString("name", layer.Id);
                xtw.WriteElementString("visibility", layer.Visible ? "1" : "0");

                foreach (Feature f in layer.Data.GetFeatures(queryExtents, layer.ThemeField, layer.LabelField))
                {
                    CreateFromFeature(xtw, layer, f, src, dst);
                }

                xtw.WriteEndElement(); // Folder
            }
            finally
            {
                if (src != null)
                {
                    src.Dispose();
                    dst.Dispose();
                }
            }
        }

        // Fill the unbounded area, trying to the smallest maximum Y coordinate.
        // Set the following for the best solution we find:
        //       xmin, xmax, etc.    - Bounds of the rectangle we are trying to fill.
        //       num_unpositioned    - The number of rectangles not yet positioned in this solution.
        //                             Used to control the recursion.
        //       rects()             - All rectangles for the problem, some positioned and others not.
        //                             Initially this is the partial solution we are working from.
        //                             At end, this is the best solution we could find.
        //       is_positioned()     - Indicates which rectangles are positioned in this solution.
        //       max_y               - The largest Y value for this solution.
        private void FillUnboundedArea(
            int xmin, int xmax, int ymin,
            ref int num_unpositioned, ref Rectangle[] rects, ref bool[] is_positioned)
        {
            if (num_unpositioned <= 0) return;

            // Save a copy of the solution so far.
            int best_num_unpositioned = num_unpositioned;
            Rectangle[] best_rects = (Rectangle[])rects.Clone();
            bool[] best_is_positioned = (bool[])is_positioned.Clone();

            // Currently we have no solution for this area.
            int best_max_y = int.MaxValue;

            // Loop through the available rectangles.
            for (int i = 0; i <= rects.Length - 1; i++)
            {
                // See if (this rectangle is not yet positioned and will fit.
                if (!is_positioned[i] &&
                    rects[i].Width <= xmax - xmin)
                {
                    // It will fit. Try it.
                    // **************************************************
                    // Divide the remaining area horizontally.
                    int test1_num_unpositioned = num_unpositioned - 1;
                    Rectangle[] test1_rects = (Rectangle[])rects.Clone();
                    bool[] test1_is_positioned = (bool[])is_positioned.Clone();
                    test1_rects[i].X = xmin;
                    test1_rects[i].Y = ymin;
                    test1_is_positioned[i] = true;

                    // Fill the area on the right.
                    FillBoundedArea(xmin + rects[i].Width, xmax, ymin, ymin + rects[i].Height,
                        ref test1_num_unpositioned, ref test1_rects, ref test1_is_positioned);
                    // Fill the area on the bottom.
                    FillUnboundedArea(xmin, xmax, ymin + rects[i].Height,
                        ref test1_num_unpositioned, ref test1_rects, ref test1_is_positioned);

                    // Learn about the test solution.
                    int test1_max_y =
                        MaxY(test1_rects, test1_is_positioned);

                    // See if (this is better than the current best solution.
                    if ((test1_num_unpositioned == 0) && (test1_max_y < best_max_y))
                    {
                        // The test is better. Save it.
                        best_max_y = test1_max_y;
                        best_rects = test1_rects;
                        best_is_positioned = test1_is_positioned;
                        best_num_unpositioned = test1_num_unpositioned;
                    }

                    // **************************************************
                    // Divide the remaining area vertically.
                    int test2_num_unpositioned = num_unpositioned - 1;
                    Rectangle[] test2_rects = (Rectangle[])rects.Clone();
                    bool[] test2_is_positioned = (bool[])is_positioned.Clone();
                    test2_rects[i].X = xmin;
                    test2_rects[i].Y = ymin;
                    test2_is_positioned[i] = true;

                    // Fill the area on the right.
                    FillUnboundedArea(xmin + rects[i].Width, xmax, ymin,
                        ref test2_num_unpositioned, ref test2_rects, ref test2_is_positioned);
                    // Fill the area on the bottom.
                    FillUnboundedArea(xmin, xmin + rects[i].Width, ymin + rects[i].Height,
                        ref test2_num_unpositioned, ref test2_rects, ref test2_is_positioned);

                    // Learn about the test solution.
                    int test2_max_y =
                        MaxY(test2_rects, test2_is_positioned);

                    // See if (this is better than the current best solution.
                    if ((test2_num_unpositioned == 0) && (test2_max_y < best_max_y))
                    {
                        // The test is better. Save it.
                        best_max_y = test2_max_y;
                        best_rects = test2_rects;
                        best_is_positioned = test2_is_positioned;
                        best_num_unpositioned = test2_num_unpositioned;
                    }
                } // End trying this rectangle.
            } // End looping through the rectangles.

            // Return the best solution we found.
            is_positioned = best_is_positioned;
            num_unpositioned = best_num_unpositioned;
            rects = best_rects;
        }

        // Start the recursion.
        public void AlgRecursiveDivision(int bin_width, Rectangle[] rects)
        {
            // Sort by height.
            Rectangle[] best_solution = (Rectangle[])rects.Clone();
            Array.Sort(rects, new HeightComparer());

            // Make variables to track and record the best solution.
            bool[] is_positioned = new bool[rects.Length];
            int num_unpositioned = rects.Length;

            // Perform the recursion.
            FillUnboundedArea(0, bin_width, 0, ref num_unpositioned, ref best_solution, ref is_positioned);

            // Save the best solution.
            Array.Copy(best_solution, rects, rects.Length);
        }

        // Use rectangles to fill the given sub-area.
        // Set the following for the best solution we find:
        //       xmin, xmax, etc.    - Bounds of the rectangle we are trying to fill.
        //       num_unpositioned    - The number of rectangles not yet positioned in this solution.
        //                             Used to control the recursion.
        //       rects()             - All rectangles for the problem, some positioned and others not. 
        //                             Initially this is the partial solution we are working from.
        //                             At end, this is the best solution we could find.
        //       is_positioned()     - Indicates which rectangles are positioned in this solution.
        //       max_y               - The largest Y value for this solution.
        private void FillBoundedArea(
            int xmin, int xmax, int ymin, int ymax,
            ref int numUnpositioned, ref Rectangle[] rects, ref bool[] isPositioned)
        {
            // See if every rectangle has been positioned.
            if (numUnpositioned <= 0) return;

            // Save a copy of the solution so far.
            int bestNumUnpositioned = numUnpositioned;
            Rectangle[] bestRects = (Rectangle[])rects.Clone();
            bool[] bestIsPositioned = (bool[])isPositioned.Clone();

            // Currently we have no solution for this area.
            double bestDensity = 0;

            // Some rectangles have not been positioned.
            // Loop through the available rectangles.
            for (int i = 0; i <= rects.Length - 1; i++)
            {
                // See if this rectangle is not position and will fit.
                if ((!isPositioned[i]) &&
                    (rects[i].Width <= xmax - xmin) &&
                    (rects[i].Height <= ymax - ymin))
                {
                    // It will fit. Try it.
                    // **************************************************
                    // Divide the remaining area horizontally.
                    int test1NumUnpositioned = numUnpositioned - 1;
                    Rectangle[] test1Rects = (Rectangle[])rects.Clone();
                    bool[] test1IsPositioned = (bool[])isPositioned.Clone();
                    test1Rects[i].X = xmin;
                    test1Rects[i].Y = ymin;
                    test1IsPositioned[i] = true;

                    // Fill the area on the right.
                    FillBoundedArea(xmin + rects[i].Width, xmax, ymin, ymin + rects[i].Height,
                        ref test1NumUnpositioned, ref test1Rects, ref test1IsPositioned);
                    // Fill the area on the bottom.
                    FillBoundedArea(xmin, xmax, ymin + rects[i].Height, ymax,
                        ref test1NumUnpositioned, ref test1Rects, ref test1IsPositioned);

                    // Learn about the test solution.
                    double test1Density =
                        SolutionDensity(
                            xmin + rects[i].Width, xmax, ymin, ymin + rects[i].Height,
                            xmin, xmax, ymin + rects[i].Height, ymax,
                            test1Rects, test1IsPositioned);

                    // See if this is better than the current best solution.
                    if (test1Density >= bestDensity)
                    {
                        // The test is better. Save it.
                        bestDensity = test1Density;
                        bestRects = test1Rects;
                        bestIsPositioned = test1IsPositioned;
                        bestNumUnpositioned = test1NumUnpositioned;
                    }

                    // **************************************************
                    // Divide the remaining area vertically.
                    int test2NumUnpositioned = numUnpositioned - 1;
                    Rectangle[] test2Rects = (Rectangle[])rects.Clone();
                    bool[] test2IsPositioned = (bool[])isPositioned.Clone();
                    test2Rects[i].X = xmin;
                    test2Rects[i].Y = ymin;
                    test2IsPositioned[i] = true;

                    // Fill the area on the right.
                    FillBoundedArea(xmin + rects[i].Width, xmax, ymin, ymax,
                        ref test2NumUnpositioned, ref test2Rects, ref test2IsPositioned);
                    // Fill the area on the bottom.
                    FillBoundedArea(xmin, xmin + rects[i].Width, ymin + rects[i].Height, ymax,
                        ref test2NumUnpositioned, ref test2Rects, ref test2IsPositioned);

                    // Learn about the test solution.
                    double test2Density =
                        SolutionDensity(
                            xmin + rects[i].Width, xmax, ymin, ymax,
                            xmin, xmin + rects[i].Width, ymin + rects[i].Height, ymax,
                            test2Rects, test2IsPositioned);

                    // See if this is better than the current best solution.
                    if (test2Density >= bestDensity)
                    {
                        // The test is better. Save it.
                        bestDensity = test2Density;
                        bestRects = test2Rects;
                        bestIsPositioned = test2IsPositioned;
                        bestNumUnpositioned = test2NumUnpositioned;
                    }
//.........这里部分代码省略.........