Пример #1
0
        }//end:DecreaseRun

        /// <summary>
        /// Finds the run with the least remains for given ets
        /// by trying every run from ets.MaxRun to 0.
        /// </summary>
        /// <param name="ets">Ets count cannot be > ETS_ON_SHEET</param>
        /// <returns></returns>
        protected static OutStats FindBestRun(Zakaz ets)
        {
            if (ets.Count > Constants.ETS_ON_SHEET)
            {
                throw new ArgumentException("FindBestRun cannot operate with so many ets.");
            }

            int      currentRun = ets.MaxRun;
            OutStats bestResult = GetStatsForRun(ets, currentRun); //Initialize bestResult

            if (!bestResult.IsValid)
            {
                throw new Exception("FindBestRun: Invalid stats obtained for MaxRun. Internal logic error.");
            }
            const int STEP = 100;

            currentRun -= STEP;
            while (currentRun > 0)
            {
                OutStats result = GetStatsForRun(ets, currentRun);
                if (result.IsValid && result < bestResult)
                {
                    bestResult = result;
                }
                currentRun -= STEP;
            }
            return(bestResult);
        }//end:FindBestRun
Пример #2
0
        }//end:IsGcd

        /// <summary>
        /// Calculates statistics for given set of ets,
        /// which would be printed with given run
        /// </summary>
        protected static OutStats GetStatsForRun(Zakaz ets, int run)
        {
            OutStats result = new OutStats();

            result.Run = run;
            foreach (Etyketka et in ets)
            {
                Etyketka tmpEt = new Etyketka(et);
                if (et.Run > run)
                {
                    tmpEt.CountOnSheet = et.Run / run; //ex. 7/3=2
                    int remainder = et.Run % run;      //Get the remainder
                    if (remainder > 0)                 // "Round up" if there is some remainer
                    {
                        tmpEt.Overprint = run - remainder;
                        tmpEt.CountOnSheet++;
                    }
                }
                else
                {
                    tmpEt.CountOnSheet = 1;
                    tmpEt.Overprint    = run - et.Run;
                }
                if (tmpEt.Overprint < 0)
                {
                    throw new ArithmeticException("GetStatsForRun: something is wrong, negative Overprints detected!");
                }
                result.Ets.Add(tmpEt);
                result.EtsOnSheetCount += tmpEt.CountOnSheet;
                result.OverprintsSum   += tmpEt.Overprint;
            } //foreach
            return(result);
        }     //end:GetEtsOnSheetForRun
Пример #3
0
        }//end:SplitFromMinToMax

        /// <summary>
        /// Determines minimum run for given Zakaz,
        /// which produces valid OutStats
        /// </summary>
        /// <param name="ets">Given zakaz remains immutable</param>
        /// <returns>Minimum valid run</returns>
        protected static int GetMinValidRun(Zakaz ets)
        {
            // Obtain stats for minimum run
            int      run      = ets.MinRun;
            OutStats tmpStats = GetStatsForRun(ets, run);

            while (!tmpStats.IsValid)
            {
                run     += 100; //Increase the run and the EtsOnSheetCount being decreased
                tmpStats = GetStatsForRun(ets, run);
            }
            return(run);
        }//end:GetMinValidRun
Пример #4
0
        }     //end:GetEtsOnSheetForRun

        /// <summary>
        /// Tries to decrease given run to maximize the fill of the sheet with given ets
        /// </summary>
        protected static OutStats DecreaseRun(Zakaz ets, int run)
        {
            //Get the etsOnSheetSum for the run
            OutStats result = GetStatsForRun(ets, run);

            if (!result.IsValid)
            {
                throw new ArithmeticException("DecreaseRun: EtsOnSheetCount sum bigger than ETS_ON_SHEET. That is nonesense!");
            }
            if (result.EtsOnSheetCount == Constants.ETS_ON_SHEET)
            {
                return(result);
            }

            //Try to increase the run for every single et and choose the best result
            OutStats tmpStats = null;
            int      etCount;

            foreach (Etyketka et in ets)
            {
                etCount = et.CountOnSheet;
                do
                {
                    etCount += 1;
                    //Fit the run so, that etsOnSheet count for the et increased by 1
                    //and get the stats for the newRun
                    tmpStats = GetStatsForRun(ets, et.Run / etCount);
                    //Choose the best result
                    if (tmpStats.IsValid && tmpStats < result)
                    {
                        result = tmpStats;
                    }
                } while (tmpStats.IsValid);
            }//foreach

            //If something went wrong and all ets have some greater-than-zero overprint, fix that
            int resultMinOverprint = (from e in result.Ets select e.Overprint).Min();

            if (resultMinOverprint > 0)
            {
                return(GetStatsForRun(result.Ets, result.Run - resultMinOverprint));
            }
            else
            {
                return(result);
            }
        }//end:DecreaseRun
Пример #5
0
        }//end:FindBestRun

        ///<summary>
        ///Splits provided list of ets and applies FirstPass on each sublist.
        ///Collects OutStats from each FirstPass and returns them as single list.
        ///</summary>
        protected static StatsList SplitFromMinToMax(Zakaz ets)
        {
            //Make given ets immutable
            Zakaz _ets = new Zakaz(ets);

            //Order ets by runs
            _ets.Sort(new CompareEtsByRunMinToMax());

            int       runIncrement   = 0;
            StatsList TheBestResult  = null;
            Zakaz     zakazForMinRun = null;
            OutStats  statsForMinRun = null;

            do
            {
                //Split ets to groups with the sum count on the sheet <= Constants.ETS_ON_SHEET
                //and build temporary stats list
                statsForMinRun = GetStatsForRun(_ets, _ets.MinRun + runIncrement);
                //For now statsForMinRun are not valid, but we don't bother,
                //because we would split ets later
                zakazForMinRun = statsForMinRun.Ets;

                StatsList tmpResult = new StatsList();
                Zakaz     part1;
                Zakaz     part2;
                do
                {
                    part1 = new Zakaz();
                    part2 = new Zakaz();
                    int count = 0;
                    foreach (Etyketka et in zakazForMinRun)
                    {
                        if (count + et.CountOnSheet <= Constants.ETS_ON_SHEET)
                        {
                            //Select first ets group that fits at one sheet
                            part1.Add(et);
                        }
                        else
                        {
                            //Add all other ets to the second group
                            part2.Add(et);
                        }
                        count += et.CountOnSheet;
                    }//foreach
                    //Part1 is valid, as far as previous if-expression is true
                    OutStats os = GetStatsForRun(part1, part1.MinRun + runIncrement);
                    if (!os.IsValid)
                    {
                        if (TheBestResult != null)
                        {
                            return(TheBestResult);
                        }
                        else
                        {
                            throw new Exception("Invalid Algorithm!");
                        }
                    }
                    tmpResult.Add(os);
                    //For second group recalculating stats with its MinRun
                    if (part2.Count > 0)
                    {
                        statsForMinRun = GetStatsForRun(part2, part2.MinRun + runIncrement);
                        //For now statsForMinRun are not valid, but we don't bother,
                        //because we would split part2 in the next loop
                        zakazForMinRun = statsForMinRun.Ets;
                    }
                } while (part2.Count > 0);

                //Select the best result as the final result returned
                if (TheBestResult == null)
                {
                    TheBestResult = tmpResult;
                }
                if (TheBestResult > tmpResult)
                {
                    TheBestResult = tmpResult;
                }

                runIncrement += 100;
            } while (_ets.MinRun + runIncrement <= _ets.MaxRun);
            return(TheBestResult);
        }//end:SplitFromMinToMax